Subversion Repositories SmartDukaan

Rev

Rev 9895 | Rev 10097 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5944 mandeep.dh 1 
#
2 
# Autogenerated by Thrift Compiler (0.7.0)
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
import shop2020.thriftpy.generic.GenericService
9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol, TProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def addItem(self, item):
21 
    """
22 
    Availability and inventory attributes
23 
 
24 
    Parameters:
25 
     - item
26 
    """
27 
    pass
28 
 
29 
  def updateItem(self, item):
30 
    """
31 
    Parameters:
32 
     - item
33 
    """
34 
    pass
35 
 
36 
  def isActive(self, itemId):
37 
    """
38 
    Checks if the item given to the corresponding itemId is active. If it's active,
39 
    whether it's risky and if it's risky, its inventory position.
40 
 
41 
    Parameters:
42 
     - itemId
43 
    """
44 
    pass
45 
 
7438 amit.gupta 46 
  def getItemsStatus(self, itemIds):
47 
    """
48 
    Parameters:
49 
     - itemIds
50 
    """
51 
    pass
52 
 
5944 mandeep.dh 53 
  def getItemStatusDescription(self, itemId):
54 
    """
55 
    Parameters:
56 
     - itemId
57 
    """
58 
    pass
59 
 
60 
  def startItemOn(self, item_id, timestamp):
61 
    """
62 
    Parameters:
63 
     - item_id
64 
     - timestamp
65 
    """
66 
    pass
67 
 
68 
  def retireItemOn(self, item_id, timestamp):
69 
    """
70 
    Parameters:
71 
     - item_id
72 
     - timestamp
73 
    """
74 
    pass
75 
 
76 
  def changeItemStatus(self, item_id, timestamp, newstatus):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
     - timestamp
81 
     - newstatus
82 
    """
83 
    pass
84 
 
85 
  def getItem(self, item_id):
86 
    """
87 
    Parameters:
88 
     - item_id
89 
    """
90 
    pass
91 
 
92 
  def getItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getValidItemsByCatalogId(self, catalog_item_id):
100 
    """
101 
    Parameters:
102 
     - catalog_item_id
103 
    """
104 
    pass
105 
 
106 
  def getAllItems(self, isActive):
107 
    """
108 
    Parameters:
109 
     - isActive
110 
    """
111 
    pass
112 
 
113 
  def getAllItemsByStatus(self, itemStatus):
114 
    """
115 
    Parameters:
116 
     - itemStatus
117 
    """
118 
    pass
119 
 
9253 rajveer 120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
9253 rajveer 128 
     - isAndroid
5944 mandeep.dh 129 
    """
130 
    pass
131 
 
132 
  def getAllItemsInRange(self, offset, limit):
133 
    """
134 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
135 
 
136 
    Parameters:
137 
     - offset
138 
     - limit
139 
    """
140 
    pass
141 
 
142 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
143 
    """
144 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
145 
 
146 
    Parameters:
147 
     - itemStatus
148 
     - offset
149 
     - limit
150 
    """
151 
    pass
152 
 
153 
  def getItemCountByStatus(self, useStatus, itemStatus):
154 
    """
155 
    Gets a count of all items by status
156 
 
157 
    Parameters:
158 
     - useStatus
159 
     - itemStatus
160 
    """
161 
    pass
162 
 
163 
  def getBestSellers(self, ):
164 
    pass
165 
 
166 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
167 
    """
168 
    Parameters:
169 
     - beginIndex
170 
     - totalItems
171 
     - brand
172 
     - category
173 
    """
174 
    pass
175 
 
176 
  def getBestSellersCount(self, ):
177 
    pass
178 
 
179 
  def getBestDeals(self, ):
180 
    pass
181 
 
182 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
183 
    """
184 
    Parameters:
185 
     - beginIndex
186 
     - totalItems
187 
     - brand
188 
     - category
189 
    """
190 
    pass
191 
 
192 
  def getBestDealsCount(self, ):
193 
    pass
194 
 
195 
  def getComingSoon(self, ):
196 
    pass
197 
 
198 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
199 
    """
200 
    Parameters:
201 
     - beginIndex
202 
     - totalItems
203 
     - brand
204 
     - category
205 
    """
206 
    pass
207 
 
208 
  def getComingSoonCount(self, ):
209 
    pass
210 
 
211 
  def getLatestArrivals(self, ):
212 
    """
213 
    Returns a list of items sorted in the descending order by start date.
214 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
215 
    """
216 
    pass
217 
 
218 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
219 
    """
220 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
221 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
222 
 
223 
    Parameters:
224 
     - beginIndex
225 
     - totalItems
226 
     - brand
227 
     - categories
228 
    """
229 
    pass
230 
 
231 
  def getLatestArrivalsCount(self, ):
232 
    """
233 
    Get the total number of latest arrivals we are willing to show.
234 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
235 
    """
236 
    pass
237 
 
238 
  def generateNewEntityID(self, ):
239 
    pass
240 
 
241 
  def addCategory(self, category):
242 
    """
243 
    All category related functions
244 
 
245 
    Parameters:
246 
     - category
247 
    """
248 
    pass
249 
 
250 
  def getCategory(self, id):
251 
    """
252 
    Parameters:
253 
     - id
254 
    """
255 
    pass
256 
 
257 
  def getAllCategories(self, ):
258 
    pass
259 
 
260 
  def getAllSimilarItems(self, itemId):
261 
    """
262 
    Returns the list of similar items.
263 
 
264 
    Parameters:
265 
     - itemId
266 
    """
267 
    pass
268 
 
269 
  def addSimilarItem(self, itemId, catalogItemId):
270 
    """
271 
    Adds similar item.
272 
 
273 
    Parameters:
274 
     - itemId
275 
     - catalogItemId
276 
    """
277 
    pass
278 
 
6512 kshitij.so 279 
  def addTag(self, displayName, itemId):
280 
    """
281 
    Tag Related
282 
 
283 
    Parameters:
284 
     - displayName
285 
     - itemId
286 
    """
287 
    pass
288 
 
289 
  def deleteEntityTag(self, displayName, itemId):
290 
    """
291 
    Parameters:
292 
     - displayName
293 
     - itemId
294 
    """
295 
    pass
296 
 
297 
  def deleteTag(self, displayName):
298 
    """
299 
    Parameters:
300 
     - displayName
301 
    """
302 
    pass
303 
 
304 
  def getAllTags(self, ):
305 
    pass
306 
 
307 
  def getAllEntitiesByTagName(self, displayName):
308 
    """
309 
    Parameters:
310 
     - displayName
311 
    """
312 
    pass
313 
 
6845 amit.gupta 314 
  def getAllEntityTags(self, ):
315 
    pass
316 
 
8590 kshitij.so 317 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 318 
    """
8579 kshitij.so 319 
    Banner Related
320 
 
6850 kshitij.so 321 
    Parameters:
8590 kshitij.so 322 
     - bannerCongregate
6850 kshitij.so 323 
    """
324 
    pass
325 
 
8579 kshitij.so 326 
  def updateBanner(self, banner):
327 
    """
328 
    Parameters:
329 
     - banner
330 
    """
331 
    pass
332 
 
6850 kshitij.so 333 
  def getAllBanners(self, ):
334 
    pass
335 
 
9155 kshitij.so 336 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 337 
    """
338 
    Parameters:
339 
     - bannerName
9155 kshitij.so 340 
     - bannerType
6850 kshitij.so 341 
    """
342 
    pass
343 
 
9155 kshitij.so 344 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 345 
    """
346 
    Parameters:
347 
     - bannerName
9155 kshitij.so 348 
     - bannerType
6850 kshitij.so 349 
    """
350 
    pass
351 
 
352 
  def getActiveBanners(self, ):
353 
    pass
354 
 
8579 kshitij.so 355 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 356 
    """
357 
    Parameters:
8579 kshitij.so 358 
     - bannerMaps
6849 kshitij.so 359 
    """
360 
    pass
361 
 
8579 kshitij.so 362 
  def updateBannerMap(self, bannerMap):
363 
    """
364 
    Parameters:
365 
     - bannerMap
366 
    """
367 
    pass
368 
 
6849 kshitij.so 369 
  def deleteBannerMap(self, bannerName):
370 
    """
371 
    Parameters:
372 
     - bannerName
373 
    """
374 
    pass
375 
 
9155 kshitij.so 376 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 377 
    """
378 
    Parameters:
379 
     - bannerName
9155 kshitij.so 380 
     - bannerType
6849 kshitij.so 381 
    """
382 
    pass
383 
 
8579 kshitij.so 384 
  def addBannerUri(self, bannerUriMappings):
385 
    """
386 
    Parameters:
387 
     - bannerUriMappings
388 
    """
389 
    pass
390 
 
9155 kshitij.so 391 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 392 
    """
393 
    Parameters:
394 
     - bannerName
9155 kshitij.so 395 
     - bannerType
8579 kshitij.so 396 
    """
397 
    pass
398 
 
399 
  def addCampaign(self, campaign):
400 
    """
401 
    Parameters:
402 
     - campaign
403 
    """
404 
    pass
405 
 
406 
  def getCampaigns(self, campaignName):
407 
    """
408 
    Parameters:
409 
     - campaignName
410 
    """
411 
    pass
412 
 
413 
  def deleteCampaign(self, campaignId):
414 
    """
415 
    Parameters:
416 
     - campaignId
417 
    """
418 
    pass
419 
 
420 
  def getAllCampaigns(self, ):
421 
    pass
422 
 
9155 kshitij.so 423 
  def getActiveBannersForMobileSite(self, ):
424 
    pass
425 
 
5944 mandeep.dh 426 
  def deleteSimilarItem(self, itemId, catalogItemId):
427 
    """
428 
    Delete similar item.
429 
 
430 
    Parameters:
431 
     - itemId
432 
     - catalogItemId
433 
    """
434 
    pass
435 
 
436 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
437 
    """
438 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
439 
    If yes, returns the itemId else returns 0
440 
 
441 
    Parameters:
442 
     - brand
443 
     - modelNumber
444 
     - modelName
445 
     - color
446 
    """
447 
    pass
448 
 
449 
  def validateRiskyStatus(self, itemId):
450 
    """
451 
    Check wether item is risky and change status if inventory is not available for risky items
452 
 
453 
    Parameters:
454 
     - itemId
455 
    """
456 
    pass
457 
 
458 
  def changeItemRiskyFlag(self, itemId, risky):
459 
    """
460 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
461 
 
462 
    Parameters:
463 
     - itemId
464 
     - risky
465 
    """
466 
    pass
467 
 
468 
  def getItemsByRiskyFlag(self, ):
469 
    """
470 
    Returns list of items marked as risky.
471 
    """
472 
    pass
473 
 
474 
  def getItemsForMasterSheet(self, category, brand):
475 
    """
476 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
477 
 
478 
    Parameters:
479 
     - category
480 
     - brand
481 
    """
482 
    pass
483 
 
484 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
485 
    """
486 
    Returns list of catalog ids of items with same similarity index as of the given itemId
487 
 
488 
    Parameters:
489 
     - beginIndex
490 
     - totalItems
491 
     - itemId
492 
    """
493 
    pass
494 
 
495 
  def addProductNotification(self, itemId, email):
496 
    """
497 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
498 
 
499 
    Parameters:
500 
     - itemId
501 
     - email
502 
    """
503 
    pass
504 
 
505 
  def sendProductNotifications(self, ):
506 
    """
507 
    Send the product notifications to the users for items which has stock.
508 
    """
509 
    pass
510 
 
511 
  def getAllBrandsByCategory(self, categoryId):
512 
    """
513 
    Returns list of brand names for a given category Id
514 
 
515 
    Parameters:
516 
     - categoryId
517 
    """
518 
    pass
519 
 
520 
  def getAllBrands(self, ):
521 
    """
522 
    Returns list of brand names
523 
    """
524 
    pass
525 
 
526 
  def getAllSources(self, ):
527 
    """
528 
    Return list of all sources
529 
    """
530 
    pass
531 
 
532 
  def getItemPricingBySource(self, itemId, sourceId):
533 
    """
534 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
535 
 
536 
    Parameters:
537 
     - itemId
538 
     - sourceId
539 
    """
540 
    pass
541 
 
542 
  def addSourceItemPricing(self, sourceItemPricing):
543 
    """
544 
    Adds prices to be displayed corresponding to the item if user comes from a source.
545 
    If item is not found or source is not found, it will throw exception.
546 
 
547 
    Parameters:
548 
     - sourceItemPricing
549 
    """
550 
    pass
551 
 
552 
  def getAllSourcePricing(self, itemId):
553 
    """
554 
    Returns the list of source pricing information of an item.
555 
    Raises an exception if item not found corresponding to itemId
556 
 
557 
    Parameters:
558 
     - itemId
559 
    """
560 
    pass
561 
 
562 
  def getItemForSource(self, item_id, sourceId):
563 
    """
564 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
565 
 
566 
    Parameters:
567 
     - item_id
568 
     - sourceId
569 
    """
570 
    pass
571 
 
572 
  def searchItemsInRange(self, searchTerms, offset, limit):
573 
    """
574 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
575 
 
576 
    Parameters:
577 
     - searchTerms
578 
     - offset
579 
     - limit
580 
    """
581 
    pass
582 
 
583 
  def getSearchResultCount(self, searchTerms):
584 
    """
585 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
586 
 
587 
    Parameters:
588 
     - searchTerms
589 
    """
590 
    pass
591 
 
592 
  def getProductNotifications(self, startDateTime):
593 
    """
594 
    Returns a list of product notifications added after a supplied datetime
595 
 
596 
    Parameters:
597 
     - startDateTime
598 
    """
599 
    pass
600 
 
7897 amar.kumar 601 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 602 
    """
603 
    Returns a list of count of requests for product notification against each item
604 
 
605 
    Parameters:
606 
     - startDateTime
7897 amar.kumar 607 
     - categoryId
5944 mandeep.dh 608 
    """
609 
    pass
610 
 
611 
  def addAuthorizationLog(self, itemId, username, reason):
612 
    """
613 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
614 
 
615 
    Parameters:
616 
     - itemId
617 
     - username
618 
     - reason
619 
    """
620 
    pass
621 
 
622 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
623 
    """
624 
    Parameters:
625 
     - catalog_item_id
626 
     - voucherType
627 
     - voucherAmount
628 
    """
629 
    pass
630 
 
631 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
632 
    """
633 
    Parameters:
634 
     - catalog_item_id
635 
     - voucherType
636 
    """
637 
    pass
638 
 
639 
  def getVoucherAmount(self, itemId, voucherType):
640 
    """
641 
    Parameters:
642 
     - itemId
643 
     - voucherType
644 
    """
645 
    pass
646 
 
647 
  def getAllItemVouchers(self, itemId):
648 
    """
649 
    Parameters:
650 
     - itemId
651 
    """
652 
    pass
653 
 
654 
  def isValidCatalogItemId(self, catalog_item_id):
655 
    """
656 
    Parameters:
657 
     - catalog_item_id
658 
    """
659 
    pass
660 
 
7330 amit.gupta 661 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 662 
    """
663 
    Parameters:
664 
     - itemId
7330 amit.gupta 665 
     - stateId
6039 amit.gupta 666 
     - price
667 
    """
668 
    pass
5944 mandeep.dh 669 
 
6039 amit.gupta 670 
  def getVatAmountForItem(self, itemId, price):
671 
    """
672 
    Parameters:
673 
     - itemId
674 
     - price
675 
    """
676 
    pass
677 
 
6531 vikram.rag 678 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
679 
    """
680 
    Parameters:
681 
     - offset
682 
     - limit
683 
    """
684 
    pass
6039 amit.gupta 685 
 
6821 amar.kumar 686 
  def getAllAliveItems(self, ):
687 
    pass
688 
 
6921 anupam.sin 689 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 690 
    """
691 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 692 
 
6805 anupam.sin 693 
    Parameters:
694 
     - itemId
6921 anupam.sin 695 
     - price
6805 anupam.sin 696 
     - insurerId
697 
     - quantity
698 
    """
699 
    pass
700 
 
701 
  def getInsurer(self, insurerId):
702 
    """
703 
    Parameters:
704 
     - insurerId
705 
    """
706 
    pass
707 
 
6838 vikram.rag 708 
  def getAllInsurers(self, ):
709 
    pass
6805 anupam.sin 710 
 
6962 rajveer 711 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
712 
    """
713 
    Parameters:
714 
     - insurerId
715 
     - amount
716 
    """
717 
    pass
6838 vikram.rag 718 
 
7190 amar.kumar 719 
  def getFreebieForItem(self, itemId):
720 
    """
721 
    Parameters:
722 
     - itemId
723 
    """
724 
    pass
6962 rajveer 725 
 
7190 amar.kumar 726 
  def addOrUpdateFreebieForItem(self, freebieItem):
727 
    """
728 
    Parameters:
729 
     - freebieItem
730 
    """
731 
    pass
732 
 
7272 amit.gupta 733 
  def addOrUpdateBrandInfo(self, brandInfo):
734 
    """
735 
    Parameters:
736 
     - brandInfo
737 
    """
738 
    pass
739 
 
740 
  def getBrandInfo(self, ):
741 
    pass
742 
 
7256 rajveer 743 
  def getStorePricing(self, itemId):
744 
    """
745 
    Parameters:
746 
     - itemId
747 
    """
748 
    pass
7190 amar.kumar 749 
 
7306 rajveer 750 
  def getStorePricings(self, itemIds):
751 
    """
752 
    Parameters:
753 
     - itemIds
754 
    """
755 
    pass
756 
 
7382 rajveer 757 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 758 
    """
759 
    Parameters:
760 
     - sp
7382 rajveer 761 
     - allColors
7265 rajveer 762 
    """
763 
    pass
7256 rajveer 764 
 
7281 kshitij.so 765 
  def getAllAmazonListedItems(self, ):
766 
    pass
7265 rajveer 767 
 
8619 kshitij.so 768 
  def searchAmazonItems(self, searchTerm, offset, limit):
769 
    """
770 
    Parameters:
771 
     - searchTerm
772 
     - offset
773 
     - limit
774 
    """
775 
    pass
776 
 
777 
  def getAmazonSearchResultCount(self, searchTerm):
778 
    """
779 
    Parameters:
780 
     - searchTerm
781 
    """
782 
    pass
783 
 
784 
  def getCountForAmazonlistedItems(self, ):
785 
    pass
786 
 
7281 kshitij.so 787 
  def getAmazonItemDetails(self, itemId):
788 
    """
789 
    Parameters:
790 
     - itemId
791 
    """
792 
    pass
793 
 
8168 kshitij.so 794 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 795 
    """
796 
    Parameters:
8168 kshitij.so 797 
     - amazonlisted
7281 kshitij.so 798 
    """
799 
    pass
800 
 
801 
  def addAmazonItem(self, amazonlisted):
802 
    """
803 
    Parameters:
804 
     - amazonlisted
805 
    """
806 
    pass
807 
 
7291 vikram.rag 808 
  def getAsinItems(self, ):
809 
    pass
7281 kshitij.so 810 
 
7291 vikram.rag 811 
  def getAllFbaListedItems(self, ):
812 
    pass
813 
 
814 
  def getAllNonFbaListedItems(self, ):
815 
    pass
816 
 
7460 kshitij.so 817 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
818 
    """
819 
    Parameters:
820 
     - itemId
821 
     - holdInventory
822 
     - defaultInventory
823 
    """
824 
    pass
7291 vikram.rag 825 
 
7770 kshitij.so 826 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
827 
    """
828 
    Parameters:
829 
     - type
830 
     - sku
831 
     - timestamp
832 
    """
833 
    pass
7460 kshitij.so 834 
 
7897 amar.kumar 835 
  def getAllParentCategories(self, ):
836 
    pass
7770 kshitij.so 837 
 
7977 kshitij.so 838 
  def addPageViewEvent(self, pageViewEvents):
839 
    """
840 
    Parameters:
841 
     - pageViewEvents
842 
    """
843 
    pass
7897 amar.kumar 844 
 
7977 kshitij.so 845 
  def addCartEvent(self, cartEvents):
846 
    """
847 
    Parameters:
848 
     - cartEvents
849 
    """
850 
    pass
851 
 
8182 amar.kumar 852 
  def addEbayItem(self, ebayItem):
853 
    """
854 
    Parameters:
855 
     - ebayItem
856 
    """
857 
    pass
858 
 
859 
  def getEbayItem(self, listingId):
860 
    """
861 
    Parameters:
862 
     - listingId
863 
    """
864 
    pass
865 
 
866 
  def updateEbayItem(self, ebayItem):
867 
    """
868 
    Parameters:
869 
     - ebayItem
870 
    """
871 
    pass
872 
 
8139 kshitij.so 873 
  def getAmazonListedItems(self, offset, limit):
874 
    """
875 
    Parameters:
876 
     - offset
877 
     - limit
878 
    """
879 
    pass
7977 kshitij.so 880 
 
8168 kshitij.so 881 
  def updateAmazonAttributesInBulk(self, amazonlisted):
882 
    """
883 
    Parameters:
884 
     - amazonlisted
885 
    """
886 
    pass
8139 kshitij.so 887 
 
8379 vikram.rag 888 
  def getAllItemstoListOnFba(self, ):
889 
    pass
8168 kshitij.so 890 
 
8379 vikram.rag 891 
  def getAllItemstoListOnNonFba(self, ):
892 
    pass
893 
 
8619 kshitij.so 894 
  def updateAsin(self, item):
895 
    """
896 
    Parameters:
897 
     - item
898 
    """
899 
    pass
8616 vikram.rag 900 
 
8739 vikram.rag 901 
  def addOrUpdateSnapdealItem(self, snapdealitem):
902 
    """
903 
    Parameters:
904 
     - snapdealitem
905 
    """
906 
    pass
8619 kshitij.so 907 
 
8739 vikram.rag 908 
  def getSnapdealItem(self, item_id):
909 
    """
910 
    Parameters:
911 
     - item_id
912 
    """
913 
    pass
914 
 
9242 kshitij.so 915 
  def getSnapdealItemDetails(self, item_id):
916 
    """
917 
    Parameters:
918 
     - item_id
919 
    """
920 
    pass
921 
 
8739 vikram.rag 922 
  def getAllSnapdealItems(self, ):
923 
    pass
924 
 
9242 kshitij.so 925 
  def getSnapdealItems(self, offset, limit):
926 
    """
927 
    Parameters:
928 
     - offset
929 
     - limit
930 
    """
931 
    pass
8739 vikram.rag 932 
 
9242 kshitij.so 933 
  def searchSnapdealItems(self, searchTerm, offset, limit):
934 
    """
935 
    Parameters:
936 
     - searchTerm
937 
     - offset
938 
     - limit
939 
    """
940 
    pass
941 
 
942 
  def getCountForSnapdealItems(self, ):
943 
    pass
944 
 
945 
  def getSnapdealSearchResultCount(self, searchTerm):
946 
    """
947 
    Parameters:
948 
     - searchTerm
949 
    """
950 
    pass
951 
 
9299 kshitij.so 952 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
953 
    """
954 
    Parameters:
955 
     - itemId
956 
     - insurerType
957 
    """
958 
    pass
9242 kshitij.so 959 
 
9456 vikram.rag 960 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
961 
    """
962 
    Parameters:
963 
     - skuAtSnapdeal
964 
    """
965 
    pass
9299 kshitij.so 966 
 
9621 manish.sha 967 
  def getProductFeedSubmit(self, catalogItemId):
968 
    """
969 
    Parameters:
970 
     - catalogItemId
971 
    """
972 
    pass
9456 vikram.rag 973 
 
9621 manish.sha 974 
  def addProductFeedSubmit(self, productFeedSubmit):
975 
    """
976 
    Parameters:
977 
     - productFeedSubmit
978 
    """
979 
    pass
980 
 
981 
  def updateProductFeedSubmit(self, productFeedSubmit):
982 
    """
983 
    Parameters:
984 
     - productFeedSubmit
985 
    """
986 
    pass
987 
 
988 
  def deleteProductFeedSubmit(self, catalogItemId):
989 
    """
990 
    Parameters:
991 
     - catalogItemId
992 
    """
993 
    pass
994 
 
995 
  def getAllProductFeedSubmit(self, ):
996 
    pass
997 
 
9724 kshitij.so 998 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
999 
    """
1000 
    Parameters:
1001 
     - itemId
1002 
     - sourceId
1003 
    """
1004 
    pass
9621 manish.sha 1005 
 
9724 kshitij.so 1006 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
1007 
    """
1008 
    Parameters:
1009 
     - marketPlaceItem
1010 
    """
1011 
    pass
1012 
 
9779 kshitij.so 1013 
  def getCostingForMarketplace(self, source, item_id):
1014 
    """
1015 
    Parameters:
1016 
     - source
1017 
     - item_id
1018 
    """
1019 
    pass
1020 
 
9776 vikram.rag 1021 
  def getMarketPlaceItemsForPriceUpdate(self, source):
1022 
    """
1023 
    Parameters:
1024 
     - source
1025 
    """
1026 
    pass
9724 kshitij.so 1027 
 
9816 kshitij.so 1028 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 1029 
    """
1030 
    Parameters:
1031 
     - skulist
1032 
     - timestamp
9816 kshitij.so 1033 
     - source
9776 vikram.rag 1034 
    """
1035 
    pass
1036 
 
9861 rajveer 1037 
  def updateItemHoldInventory(self, itemHoldMap):
1038 
    """
1039 
    Parameters:
1040 
     - itemHoldMap
1041 
    """
1042 
    pass
9776 vikram.rag 1043 
 
9895 vikram.rag 1044 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
1045 
    """
1046 
    Parameters:
1047 
     - item_id
1048 
     - vendor_id
1049 
     - nlc
1050 
    """
1051 
    pass
9861 rajveer 1052 
 
9945 vikram.rag 1053 
  def getAllFlipkartItems(self, ):
1054 
    pass
9895 vikram.rag 1055 
 
9945 vikram.rag 1056 
 
5944 mandeep.dh 1057 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1058 
  def __init__(self, iprot, oprot=None):
1059 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1060 
 
1061 
  def addItem(self, item):
1062 
    """
1063 
    Availability and inventory attributes
1064 
 
1065 
    Parameters:
1066 
     - item
1067 
    """
1068 
    self.send_addItem(item)
1069 
    return self.recv_addItem()
1070 
 
1071 
  def send_addItem(self, item):
1072 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1073 
    args = addItem_args()
1074 
    args.item = item
1075 
    args.write(self._oprot)
1076 
    self._oprot.writeMessageEnd()
1077 
    self._oprot.trans.flush()
1078 
 
1079 
  def recv_addItem(self, ):
1080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1081 
    if mtype == TMessageType.EXCEPTION:
1082 
      x = TApplicationException()
1083 
      x.read(self._iprot)
1084 
      self._iprot.readMessageEnd()
1085 
      raise x
1086 
    result = addItem_result()
1087 
    result.read(self._iprot)
1088 
    self._iprot.readMessageEnd()
1089 
    if result.success is not None:
1090 
      return result.success
1091 
    if result.cex is not None:
1092 
      raise result.cex
1093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1094 
 
1095 
  def updateItem(self, item):
1096 
    """
1097 
    Parameters:
1098 
     - item
1099 
    """
1100 
    self.send_updateItem(item)
1101 
    return self.recv_updateItem()
1102 
 
1103 
  def send_updateItem(self, item):
1104 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1105 
    args = updateItem_args()
1106 
    args.item = item
1107 
    args.write(self._oprot)
1108 
    self._oprot.writeMessageEnd()
1109 
    self._oprot.trans.flush()
1110 
 
1111 
  def recv_updateItem(self, ):
1112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1113 
    if mtype == TMessageType.EXCEPTION:
1114 
      x = TApplicationException()
1115 
      x.read(self._iprot)
1116 
      self._iprot.readMessageEnd()
1117 
      raise x
1118 
    result = updateItem_result()
1119 
    result.read(self._iprot)
1120 
    self._iprot.readMessageEnd()
1121 
    if result.success is not None:
1122 
      return result.success
1123 
    if result.cex is not None:
1124 
      raise result.cex
1125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1126 
 
1127 
  def isActive(self, itemId):
1128 
    """
1129 
    Checks if the item given to the corresponding itemId is active. If it's active,
1130 
    whether it's risky and if it's risky, its inventory position.
1131 
 
1132 
    Parameters:
1133 
     - itemId
1134 
    """
1135 
    self.send_isActive(itemId)
1136 
    return self.recv_isActive()
1137 
 
1138 
  def send_isActive(self, itemId):
1139 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1140 
    args = isActive_args()
1141 
    args.itemId = itemId
1142 
    args.write(self._oprot)
1143 
    self._oprot.writeMessageEnd()
1144 
    self._oprot.trans.flush()
1145 
 
1146 
  def recv_isActive(self, ):
1147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1148 
    if mtype == TMessageType.EXCEPTION:
1149 
      x = TApplicationException()
1150 
      x.read(self._iprot)
1151 
      self._iprot.readMessageEnd()
1152 
      raise x
1153 
    result = isActive_result()
1154 
    result.read(self._iprot)
1155 
    self._iprot.readMessageEnd()
1156 
    if result.success is not None:
1157 
      return result.success
1158 
    if result.isex is not None:
1159 
      raise result.isex
1160 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1161 
 
7438 amit.gupta 1162 
  def getItemsStatus(self, itemIds):
1163 
    """
1164 
    Parameters:
1165 
     - itemIds
1166 
    """
1167 
    self.send_getItemsStatus(itemIds)
1168 
    return self.recv_getItemsStatus()
1169 
 
1170 
  def send_getItemsStatus(self, itemIds):
1171 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1172 
    args = getItemsStatus_args()
1173 
    args.itemIds = itemIds
1174 
    args.write(self._oprot)
1175 
    self._oprot.writeMessageEnd()
1176 
    self._oprot.trans.flush()
1177 
 
1178 
  def recv_getItemsStatus(self, ):
1179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1180 
    if mtype == TMessageType.EXCEPTION:
1181 
      x = TApplicationException()
1182 
      x.read(self._iprot)
1183 
      self._iprot.readMessageEnd()
1184 
      raise x
1185 
    result = getItemsStatus_result()
1186 
    result.read(self._iprot)
1187 
    self._iprot.readMessageEnd()
1188 
    if result.success is not None:
1189 
      return result.success
1190 
    if result.isex is not None:
1191 
      raise result.isex
1192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1193 
 
5944 mandeep.dh 1194 
  def getItemStatusDescription(self, itemId):
1195 
    """
1196 
    Parameters:
1197 
     - itemId
1198 
    """
1199 
    self.send_getItemStatusDescription(itemId)
1200 
    return self.recv_getItemStatusDescription()
1201 
 
1202 
  def send_getItemStatusDescription(self, itemId):
1203 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1204 
    args = getItemStatusDescription_args()
1205 
    args.itemId = itemId
1206 
    args.write(self._oprot)
1207 
    self._oprot.writeMessageEnd()
1208 
    self._oprot.trans.flush()
1209 
 
1210 
  def recv_getItemStatusDescription(self, ):
1211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1212 
    if mtype == TMessageType.EXCEPTION:
1213 
      x = TApplicationException()
1214 
      x.read(self._iprot)
1215 
      self._iprot.readMessageEnd()
1216 
      raise x
1217 
    result = getItemStatusDescription_result()
1218 
    result.read(self._iprot)
1219 
    self._iprot.readMessageEnd()
1220 
    if result.success is not None:
1221 
      return result.success
1222 
    if result.isex is not None:
1223 
      raise result.isex
1224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1225 
 
1226 
  def startItemOn(self, item_id, timestamp):
1227 
    """
1228 
    Parameters:
1229 
     - item_id
1230 
     - timestamp
1231 
    """
1232 
    self.send_startItemOn(item_id, timestamp)
1233 
    self.recv_startItemOn()
1234 
 
1235 
  def send_startItemOn(self, item_id, timestamp):
1236 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1237 
    args = startItemOn_args()
1238 
    args.item_id = item_id
1239 
    args.timestamp = timestamp
1240 
    args.write(self._oprot)
1241 
    self._oprot.writeMessageEnd()
1242 
    self._oprot.trans.flush()
1243 
 
1244 
  def recv_startItemOn(self, ):
1245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1246 
    if mtype == TMessageType.EXCEPTION:
1247 
      x = TApplicationException()
1248 
      x.read(self._iprot)
1249 
      self._iprot.readMessageEnd()
1250 
      raise x
1251 
    result = startItemOn_result()
1252 
    result.read(self._iprot)
1253 
    self._iprot.readMessageEnd()
1254 
    if result.cex is not None:
1255 
      raise result.cex
1256 
    return
1257 
 
1258 
  def retireItemOn(self, item_id, timestamp):
1259 
    """
1260 
    Parameters:
1261 
     - item_id
1262 
     - timestamp
1263 
    """
1264 
    self.send_retireItemOn(item_id, timestamp)
1265 
    self.recv_retireItemOn()
1266 
 
1267 
  def send_retireItemOn(self, item_id, timestamp):
1268 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1269 
    args = retireItemOn_args()
1270 
    args.item_id = item_id
1271 
    args.timestamp = timestamp
1272 
    args.write(self._oprot)
1273 
    self._oprot.writeMessageEnd()
1274 
    self._oprot.trans.flush()
1275 
 
1276 
  def recv_retireItemOn(self, ):
1277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1278 
    if mtype == TMessageType.EXCEPTION:
1279 
      x = TApplicationException()
1280 
      x.read(self._iprot)
1281 
      self._iprot.readMessageEnd()
1282 
      raise x
1283 
    result = retireItemOn_result()
1284 
    result.read(self._iprot)
1285 
    self._iprot.readMessageEnd()
1286 
    if result.cex is not None:
1287 
      raise result.cex
1288 
    return
1289 
 
1290 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1291 
    """
1292 
    Parameters:
1293 
     - item_id
1294 
     - timestamp
1295 
     - newstatus
1296 
    """
1297 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1298 
    self.recv_changeItemStatus()
1299 
 
1300 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1301 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1302 
    args = changeItemStatus_args()
1303 
    args.item_id = item_id
1304 
    args.timestamp = timestamp
1305 
    args.newstatus = newstatus
1306 
    args.write(self._oprot)
1307 
    self._oprot.writeMessageEnd()
1308 
    self._oprot.trans.flush()
1309 
 
1310 
  def recv_changeItemStatus(self, ):
1311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1312 
    if mtype == TMessageType.EXCEPTION:
1313 
      x = TApplicationException()
1314 
      x.read(self._iprot)
1315 
      self._iprot.readMessageEnd()
1316 
      raise x
1317 
    result = changeItemStatus_result()
1318 
    result.read(self._iprot)
1319 
    self._iprot.readMessageEnd()
1320 
    if result.cex is not None:
1321 
      raise result.cex
1322 
    return
1323 
 
1324 
  def getItem(self, item_id):
1325 
    """
1326 
    Parameters:
1327 
     - item_id
1328 
    """
1329 
    self.send_getItem(item_id)
1330 
    return self.recv_getItem()
1331 
 
1332 
  def send_getItem(self, item_id):
1333 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1334 
    args = getItem_args()
1335 
    args.item_id = item_id
1336 
    args.write(self._oprot)
1337 
    self._oprot.writeMessageEnd()
1338 
    self._oprot.trans.flush()
1339 
 
1340 
  def recv_getItem(self, ):
1341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1342 
    if mtype == TMessageType.EXCEPTION:
1343 
      x = TApplicationException()
1344 
      x.read(self._iprot)
1345 
      self._iprot.readMessageEnd()
1346 
      raise x
1347 
    result = getItem_result()
1348 
    result.read(self._iprot)
1349 
    self._iprot.readMessageEnd()
1350 
    if result.success is not None:
1351 
      return result.success
1352 
    if result.cex is not None:
1353 
      raise result.cex
1354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1355 
 
1356 
  def getItemsByCatalogId(self, catalog_item_id):
1357 
    """
1358 
    Parameters:
1359 
     - catalog_item_id
1360 
    """
1361 
    self.send_getItemsByCatalogId(catalog_item_id)
1362 
    return self.recv_getItemsByCatalogId()
1363 
 
1364 
  def send_getItemsByCatalogId(self, catalog_item_id):
1365 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1366 
    args = getItemsByCatalogId_args()
1367 
    args.catalog_item_id = catalog_item_id
1368 
    args.write(self._oprot)
1369 
    self._oprot.writeMessageEnd()
1370 
    self._oprot.trans.flush()
1371 
 
1372 
  def recv_getItemsByCatalogId(self, ):
1373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1374 
    if mtype == TMessageType.EXCEPTION:
1375 
      x = TApplicationException()
1376 
      x.read(self._iprot)
1377 
      self._iprot.readMessageEnd()
1378 
      raise x
1379 
    result = getItemsByCatalogId_result()
1380 
    result.read(self._iprot)
1381 
    self._iprot.readMessageEnd()
1382 
    if result.success is not None:
1383 
      return result.success
1384 
    if result.cex is not None:
1385 
      raise result.cex
1386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1387 
 
1388 
  def getValidItemsByCatalogId(self, catalog_item_id):
1389 
    """
1390 
    Parameters:
1391 
     - catalog_item_id
1392 
    """
1393 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1394 
    return self.recv_getValidItemsByCatalogId()
1395 
 
1396 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1397 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1398 
    args = getValidItemsByCatalogId_args()
1399 
    args.catalog_item_id = catalog_item_id
1400 
    args.write(self._oprot)
1401 
    self._oprot.writeMessageEnd()
1402 
    self._oprot.trans.flush()
1403 
 
1404 
  def recv_getValidItemsByCatalogId(self, ):
1405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1406 
    if mtype == TMessageType.EXCEPTION:
1407 
      x = TApplicationException()
1408 
      x.read(self._iprot)
1409 
      self._iprot.readMessageEnd()
1410 
      raise x
1411 
    result = getValidItemsByCatalogId_result()
1412 
    result.read(self._iprot)
1413 
    self._iprot.readMessageEnd()
1414 
    if result.success is not None:
1415 
      return result.success
1416 
    if result.cex is not None:
1417 
      raise result.cex
1418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1419 
 
1420 
  def getAllItems(self, isActive):
1421 
    """
1422 
    Parameters:
1423 
     - isActive
1424 
    """
1425 
    self.send_getAllItems(isActive)
1426 
    return self.recv_getAllItems()
1427 
 
1428 
  def send_getAllItems(self, isActive):
1429 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1430 
    args = getAllItems_args()
1431 
    args.isActive = isActive
1432 
    args.write(self._oprot)
1433 
    self._oprot.writeMessageEnd()
1434 
    self._oprot.trans.flush()
1435 
 
1436 
  def recv_getAllItems(self, ):
1437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1438 
    if mtype == TMessageType.EXCEPTION:
1439 
      x = TApplicationException()
1440 
      x.read(self._iprot)
1441 
      self._iprot.readMessageEnd()
1442 
      raise x
1443 
    result = getAllItems_result()
1444 
    result.read(self._iprot)
1445 
    self._iprot.readMessageEnd()
1446 
    if result.success is not None:
1447 
      return result.success
1448 
    if result.cex is not None:
1449 
      raise result.cex
1450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1451 
 
1452 
  def getAllItemsByStatus(self, itemStatus):
1453 
    """
1454 
    Parameters:
1455 
     - itemStatus
1456 
    """
1457 
    self.send_getAllItemsByStatus(itemStatus)
1458 
    return self.recv_getAllItemsByStatus()
1459 
 
1460 
  def send_getAllItemsByStatus(self, itemStatus):
1461 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1462 
    args = getAllItemsByStatus_args()
1463 
    args.itemStatus = itemStatus
1464 
    args.write(self._oprot)
1465 
    self._oprot.writeMessageEnd()
1466 
    self._oprot.trans.flush()
1467 
 
1468 
  def recv_getAllItemsByStatus(self, ):
1469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1470 
    if mtype == TMessageType.EXCEPTION:
1471 
      x = TApplicationException()
1472 
      x.read(self._iprot)
1473 
      self._iprot.readMessageEnd()
1474 
      raise x
1475 
    result = getAllItemsByStatus_result()
1476 
    result.read(self._iprot)
1477 
    self._iprot.readMessageEnd()
1478 
    if result.success is not None:
1479 
      return result.success
1480 
    if result.cex is not None:
1481 
      raise result.cex
1482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1483 
 
9253 rajveer 1484 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1485 
    """
1486 
    Parameters:
1487 
     - entityId
1488 
     - category
1489 
     - brand
1490 
     - modelName
1491 
     - modelNumber
9253 rajveer 1492 
     - isAndroid
5944 mandeep.dh 1493 
    """
9253 rajveer 1494 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1495 
    return self.recv_markItemAsContentComplete()
1496 
 
9253 rajveer 1497 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1498 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1499 
    args = markItemAsContentComplete_args()
1500 
    args.entityId = entityId
1501 
    args.category = category
1502 
    args.brand = brand
1503 
    args.modelName = modelName
1504 
    args.modelNumber = modelNumber
9253 rajveer 1505 
    args.isAndroid = isAndroid
5944 mandeep.dh 1506 
    args.write(self._oprot)
1507 
    self._oprot.writeMessageEnd()
1508 
    self._oprot.trans.flush()
1509 
 
1510 
  def recv_markItemAsContentComplete(self, ):
1511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1512 
    if mtype == TMessageType.EXCEPTION:
1513 
      x = TApplicationException()
1514 
      x.read(self._iprot)
1515 
      self._iprot.readMessageEnd()
1516 
      raise x
1517 
    result = markItemAsContentComplete_result()
1518 
    result.read(self._iprot)
1519 
    self._iprot.readMessageEnd()
1520 
    if result.success is not None:
1521 
      return result.success
1522 
    if result.cex is not None:
1523 
      raise result.cex
1524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1525 
 
1526 
  def getAllItemsInRange(self, offset, limit):
1527 
    """
1528 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1529 
 
1530 
    Parameters:
1531 
     - offset
1532 
     - limit
1533 
    """
1534 
    self.send_getAllItemsInRange(offset, limit)
1535 
    return self.recv_getAllItemsInRange()
1536 
 
1537 
  def send_getAllItemsInRange(self, offset, limit):
1538 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1539 
    args = getAllItemsInRange_args()
1540 
    args.offset = offset
1541 
    args.limit = limit
1542 
    args.write(self._oprot)
1543 
    self._oprot.writeMessageEnd()
1544 
    self._oprot.trans.flush()
1545 
 
1546 
  def recv_getAllItemsInRange(self, ):
1547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1548 
    if mtype == TMessageType.EXCEPTION:
1549 
      x = TApplicationException()
1550 
      x.read(self._iprot)
1551 
      self._iprot.readMessageEnd()
1552 
      raise x
1553 
    result = getAllItemsInRange_result()
1554 
    result.read(self._iprot)
1555 
    self._iprot.readMessageEnd()
1556 
    if result.success is not None:
1557 
      return result.success
1558 
    if result.cex is not None:
1559 
      raise result.cex
1560 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1561 
 
1562 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1563 
    """
1564 
    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.
1565 
 
1566 
    Parameters:
1567 
     - itemStatus
1568 
     - offset
1569 
     - limit
1570 
    """
1571 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1572 
    return self.recv_getAllItemsByStatusInRange()
1573 
 
1574 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1575 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1576 
    args = getAllItemsByStatusInRange_args()
1577 
    args.itemStatus = itemStatus
1578 
    args.offset = offset
1579 
    args.limit = limit
1580 
    args.write(self._oprot)
1581 
    self._oprot.writeMessageEnd()
1582 
    self._oprot.trans.flush()
1583 
 
1584 
  def recv_getAllItemsByStatusInRange(self, ):
1585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1586 
    if mtype == TMessageType.EXCEPTION:
1587 
      x = TApplicationException()
1588 
      x.read(self._iprot)
1589 
      self._iprot.readMessageEnd()
1590 
      raise x
1591 
    result = getAllItemsByStatusInRange_result()
1592 
    result.read(self._iprot)
1593 
    self._iprot.readMessageEnd()
1594 
    if result.success is not None:
1595 
      return result.success
1596 
    if result.cex is not None:
1597 
      raise result.cex
1598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1599 
 
1600 
  def getItemCountByStatus(self, useStatus, itemStatus):
1601 
    """
1602 
    Gets a count of all items by status
1603 
 
1604 
    Parameters:
1605 
     - useStatus
1606 
     - itemStatus
1607 
    """
1608 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1609 
    return self.recv_getItemCountByStatus()
1610 
 
1611 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1612 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1613 
    args = getItemCountByStatus_args()
1614 
    args.useStatus = useStatus
1615 
    args.itemStatus = itemStatus
1616 
    args.write(self._oprot)
1617 
    self._oprot.writeMessageEnd()
1618 
    self._oprot.trans.flush()
1619 
 
1620 
  def recv_getItemCountByStatus(self, ):
1621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1622 
    if mtype == TMessageType.EXCEPTION:
1623 
      x = TApplicationException()
1624 
      x.read(self._iprot)
1625 
      self._iprot.readMessageEnd()
1626 
      raise x
1627 
    result = getItemCountByStatus_result()
1628 
    result.read(self._iprot)
1629 
    self._iprot.readMessageEnd()
1630 
    if result.success is not None:
1631 
      return result.success
1632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1633 
 
1634 
  def getBestSellers(self, ):
1635 
    self.send_getBestSellers()
1636 
    return self.recv_getBestSellers()
1637 
 
1638 
  def send_getBestSellers(self, ):
1639 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1640 
    args = getBestSellers_args()
1641 
    args.write(self._oprot)
1642 
    self._oprot.writeMessageEnd()
1643 
    self._oprot.trans.flush()
1644 
 
1645 
  def recv_getBestSellers(self, ):
1646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1647 
    if mtype == TMessageType.EXCEPTION:
1648 
      x = TApplicationException()
1649 
      x.read(self._iprot)
1650 
      self._iprot.readMessageEnd()
1651 
      raise x
1652 
    result = getBestSellers_result()
1653 
    result.read(self._iprot)
1654 
    self._iprot.readMessageEnd()
1655 
    if result.success is not None:
1656 
      return result.success
1657 
    if result.isex is not None:
1658 
      raise result.isex
1659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1660 
 
1661 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1662 
    """
1663 
    Parameters:
1664 
     - beginIndex
1665 
     - totalItems
1666 
     - brand
1667 
     - category
1668 
    """
1669 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1670 
    return self.recv_getBestSellersCatalogIds()
1671 
 
1672 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1673 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1674 
    args = getBestSellersCatalogIds_args()
1675 
    args.beginIndex = beginIndex
1676 
    args.totalItems = totalItems
1677 
    args.brand = brand
1678 
    args.category = category
1679 
    args.write(self._oprot)
1680 
    self._oprot.writeMessageEnd()
1681 
    self._oprot.trans.flush()
1682 
 
1683 
  def recv_getBestSellersCatalogIds(self, ):
1684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1685 
    if mtype == TMessageType.EXCEPTION:
1686 
      x = TApplicationException()
1687 
      x.read(self._iprot)
1688 
      self._iprot.readMessageEnd()
1689 
      raise x
1690 
    result = getBestSellersCatalogIds_result()
1691 
    result.read(self._iprot)
1692 
    self._iprot.readMessageEnd()
1693 
    if result.success is not None:
1694 
      return result.success
1695 
    if result.cex is not None:
1696 
      raise result.cex
1697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1698 
 
1699 
  def getBestSellersCount(self, ):
1700 
    self.send_getBestSellersCount()
1701 
    return self.recv_getBestSellersCount()
1702 
 
1703 
  def send_getBestSellersCount(self, ):
1704 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1705 
    args = getBestSellersCount_args()
1706 
    args.write(self._oprot)
1707 
    self._oprot.writeMessageEnd()
1708 
    self._oprot.trans.flush()
1709 
 
1710 
  def recv_getBestSellersCount(self, ):
1711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1712 
    if mtype == TMessageType.EXCEPTION:
1713 
      x = TApplicationException()
1714 
      x.read(self._iprot)
1715 
      self._iprot.readMessageEnd()
1716 
      raise x
1717 
    result = getBestSellersCount_result()
1718 
    result.read(self._iprot)
1719 
    self._iprot.readMessageEnd()
1720 
    if result.success is not None:
1721 
      return result.success
1722 
    if result.cex is not None:
1723 
      raise result.cex
1724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1725 
 
1726 
  def getBestDeals(self, ):
1727 
    self.send_getBestDeals()
1728 
    return self.recv_getBestDeals()
1729 
 
1730 
  def send_getBestDeals(self, ):
1731 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1732 
    args = getBestDeals_args()
1733 
    args.write(self._oprot)
1734 
    self._oprot.writeMessageEnd()
1735 
    self._oprot.trans.flush()
1736 
 
1737 
  def recv_getBestDeals(self, ):
1738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1739 
    if mtype == TMessageType.EXCEPTION:
1740 
      x = TApplicationException()
1741 
      x.read(self._iprot)
1742 
      self._iprot.readMessageEnd()
1743 
      raise x
1744 
    result = getBestDeals_result()
1745 
    result.read(self._iprot)
1746 
    self._iprot.readMessageEnd()
1747 
    if result.success is not None:
1748 
      return result.success
1749 
    if result.isex is not None:
1750 
      raise result.isex
1751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1752 
 
1753 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1754 
    """
1755 
    Parameters:
1756 
     - beginIndex
1757 
     - totalItems
1758 
     - brand
1759 
     - category
1760 
    """
1761 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1762 
    return self.recv_getBestDealsCatalogIds()
1763 
 
1764 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1765 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1766 
    args = getBestDealsCatalogIds_args()
1767 
    args.beginIndex = beginIndex
1768 
    args.totalItems = totalItems
1769 
    args.brand = brand
1770 
    args.category = category
1771 
    args.write(self._oprot)
1772 
    self._oprot.writeMessageEnd()
1773 
    self._oprot.trans.flush()
1774 
 
1775 
  def recv_getBestDealsCatalogIds(self, ):
1776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1777 
    if mtype == TMessageType.EXCEPTION:
1778 
      x = TApplicationException()
1779 
      x.read(self._iprot)
1780 
      self._iprot.readMessageEnd()
1781 
      raise x
1782 
    result = getBestDealsCatalogIds_result()
1783 
    result.read(self._iprot)
1784 
    self._iprot.readMessageEnd()
1785 
    if result.success is not None:
1786 
      return result.success
1787 
    if result.cex is not None:
1788 
      raise result.cex
1789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1790 
 
1791 
  def getBestDealsCount(self, ):
1792 
    self.send_getBestDealsCount()
1793 
    return self.recv_getBestDealsCount()
1794 
 
1795 
  def send_getBestDealsCount(self, ):
1796 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1797 
    args = getBestDealsCount_args()
1798 
    args.write(self._oprot)
1799 
    self._oprot.writeMessageEnd()
1800 
    self._oprot.trans.flush()
1801 
 
1802 
  def recv_getBestDealsCount(self, ):
1803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1804 
    if mtype == TMessageType.EXCEPTION:
1805 
      x = TApplicationException()
1806 
      x.read(self._iprot)
1807 
      self._iprot.readMessageEnd()
1808 
      raise x
1809 
    result = getBestDealsCount_result()
1810 
    result.read(self._iprot)
1811 
    self._iprot.readMessageEnd()
1812 
    if result.success is not None:
1813 
      return result.success
1814 
    if result.cex is not None:
1815 
      raise result.cex
1816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1817 
 
1818 
  def getComingSoon(self, ):
1819 
    self.send_getComingSoon()
1820 
    return self.recv_getComingSoon()
1821 
 
1822 
  def send_getComingSoon(self, ):
1823 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1824 
    args = getComingSoon_args()
1825 
    args.write(self._oprot)
1826 
    self._oprot.writeMessageEnd()
1827 
    self._oprot.trans.flush()
1828 
 
1829 
  def recv_getComingSoon(self, ):
1830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1831 
    if mtype == TMessageType.EXCEPTION:
1832 
      x = TApplicationException()
1833 
      x.read(self._iprot)
1834 
      self._iprot.readMessageEnd()
1835 
      raise x
1836 
    result = getComingSoon_result()
1837 
    result.read(self._iprot)
1838 
    self._iprot.readMessageEnd()
1839 
    if result.success is not None:
1840 
      return result.success
1841 
    if result.isex is not None:
1842 
      raise result.isex
1843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1844 
 
1845 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1846 
    """
1847 
    Parameters:
1848 
     - beginIndex
1849 
     - totalItems
1850 
     - brand
1851 
     - category
1852 
    """
1853 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1854 
    return self.recv_getComingSoonCatalogIds()
1855 
 
1856 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1857 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1858 
    args = getComingSoonCatalogIds_args()
1859 
    args.beginIndex = beginIndex
1860 
    args.totalItems = totalItems
1861 
    args.brand = brand
1862 
    args.category = category
1863 
    args.write(self._oprot)
1864 
    self._oprot.writeMessageEnd()
1865 
    self._oprot.trans.flush()
1866 
 
1867 
  def recv_getComingSoonCatalogIds(self, ):
1868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1869 
    if mtype == TMessageType.EXCEPTION:
1870 
      x = TApplicationException()
1871 
      x.read(self._iprot)
1872 
      self._iprot.readMessageEnd()
1873 
      raise x
1874 
    result = getComingSoonCatalogIds_result()
1875 
    result.read(self._iprot)
1876 
    self._iprot.readMessageEnd()
1877 
    if result.success is not None:
1878 
      return result.success
1879 
    if result.cex is not None:
1880 
      raise result.cex
1881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1882 
 
1883 
  def getComingSoonCount(self, ):
1884 
    self.send_getComingSoonCount()
1885 
    return self.recv_getComingSoonCount()
1886 
 
1887 
  def send_getComingSoonCount(self, ):
1888 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1889 
    args = getComingSoonCount_args()
1890 
    args.write(self._oprot)
1891 
    self._oprot.writeMessageEnd()
1892 
    self._oprot.trans.flush()
1893 
 
1894 
  def recv_getComingSoonCount(self, ):
1895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1896 
    if mtype == TMessageType.EXCEPTION:
1897 
      x = TApplicationException()
1898 
      x.read(self._iprot)
1899 
      self._iprot.readMessageEnd()
1900 
      raise x
1901 
    result = getComingSoonCount_result()
1902 
    result.read(self._iprot)
1903 
    self._iprot.readMessageEnd()
1904 
    if result.success is not None:
1905 
      return result.success
1906 
    if result.cex is not None:
1907 
      raise result.cex
1908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1909 
 
1910 
  def getLatestArrivals(self, ):
1911 
    """
1912 
    Returns a list of items sorted in the descending order by start date.
1913 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1914 
    """
1915 
    self.send_getLatestArrivals()
1916 
    return self.recv_getLatestArrivals()
1917 
 
1918 
  def send_getLatestArrivals(self, ):
1919 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1920 
    args = getLatestArrivals_args()
1921 
    args.write(self._oprot)
1922 
    self._oprot.writeMessageEnd()
1923 
    self._oprot.trans.flush()
1924 
 
1925 
  def recv_getLatestArrivals(self, ):
1926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1927 
    if mtype == TMessageType.EXCEPTION:
1928 
      x = TApplicationException()
1929 
      x.read(self._iprot)
1930 
      self._iprot.readMessageEnd()
1931 
      raise x
1932 
    result = getLatestArrivals_result()
1933 
    result.read(self._iprot)
1934 
    self._iprot.readMessageEnd()
1935 
    if result.success is not None:
1936 
      return result.success
1937 
    if result.isex is not None:
1938 
      raise result.isex
1939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1940 
 
1941 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1942 
    """
1943 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1944 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1945 
 
1946 
    Parameters:
1947 
     - beginIndex
1948 
     - totalItems
1949 
     - brand
1950 
     - categories
1951 
    """
1952 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1953 
    return self.recv_getLatestArrivalsCatalogIds()
1954 
 
1955 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1956 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1957 
    args = getLatestArrivalsCatalogIds_args()
1958 
    args.beginIndex = beginIndex
1959 
    args.totalItems = totalItems
1960 
    args.brand = brand
1961 
    args.categories = categories
1962 
    args.write(self._oprot)
1963 
    self._oprot.writeMessageEnd()
1964 
    self._oprot.trans.flush()
1965 
 
1966 
  def recv_getLatestArrivalsCatalogIds(self, ):
1967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1968 
    if mtype == TMessageType.EXCEPTION:
1969 
      x = TApplicationException()
1970 
      x.read(self._iprot)
1971 
      self._iprot.readMessageEnd()
1972 
      raise x
1973 
    result = getLatestArrivalsCatalogIds_result()
1974 
    result.read(self._iprot)
1975 
    self._iprot.readMessageEnd()
1976 
    if result.success is not None:
1977 
      return result.success
1978 
    if result.cex is not None:
1979 
      raise result.cex
1980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1981 
 
1982 
  def getLatestArrivalsCount(self, ):
1983 
    """
1984 
    Get the total number of latest arrivals we are willing to show.
1985 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1986 
    """
1987 
    self.send_getLatestArrivalsCount()
1988 
    return self.recv_getLatestArrivalsCount()
1989 
 
1990 
  def send_getLatestArrivalsCount(self, ):
1991 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1992 
    args = getLatestArrivalsCount_args()
1993 
    args.write(self._oprot)
1994 
    self._oprot.writeMessageEnd()
1995 
    self._oprot.trans.flush()
1996 
 
1997 
  def recv_getLatestArrivalsCount(self, ):
1998 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1999 
    if mtype == TMessageType.EXCEPTION:
2000 
      x = TApplicationException()
2001 
      x.read(self._iprot)
2002 
      self._iprot.readMessageEnd()
2003 
      raise x
2004 
    result = getLatestArrivalsCount_result()
2005 
    result.read(self._iprot)
2006 
    self._iprot.readMessageEnd()
2007 
    if result.success is not None:
2008 
      return result.success
2009 
    if result.cex is not None:
2010 
      raise result.cex
2011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
2012 
 
2013 
  def generateNewEntityID(self, ):
2014 
    self.send_generateNewEntityID()
2015 
    return self.recv_generateNewEntityID()
2016 
 
2017 
  def send_generateNewEntityID(self, ):
2018 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2019 
    args = generateNewEntityID_args()
2020 
    args.write(self._oprot)
2021 
    self._oprot.writeMessageEnd()
2022 
    self._oprot.trans.flush()
2023 
 
2024 
  def recv_generateNewEntityID(self, ):
2025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2026 
    if mtype == TMessageType.EXCEPTION:
2027 
      x = TApplicationException()
2028 
      x.read(self._iprot)
2029 
      self._iprot.readMessageEnd()
2030 
      raise x
2031 
    result = generateNewEntityID_result()
2032 
    result.read(self._iprot)
2033 
    self._iprot.readMessageEnd()
2034 
    if result.success is not None:
2035 
      return result.success
2036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2037 
 
2038 
  def addCategory(self, category):
2039 
    """
2040 
    All category related functions
2041 
 
2042 
    Parameters:
2043 
     - category
2044 
    """
2045 
    self.send_addCategory(category)
2046 
    return self.recv_addCategory()
2047 
 
2048 
  def send_addCategory(self, category):
2049 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2050 
    args = addCategory_args()
2051 
    args.category = category
2052 
    args.write(self._oprot)
2053 
    self._oprot.writeMessageEnd()
2054 
    self._oprot.trans.flush()
2055 
 
2056 
  def recv_addCategory(self, ):
2057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2058 
    if mtype == TMessageType.EXCEPTION:
2059 
      x = TApplicationException()
2060 
      x.read(self._iprot)
2061 
      self._iprot.readMessageEnd()
2062 
      raise x
2063 
    result = addCategory_result()
2064 
    result.read(self._iprot)
2065 
    self._iprot.readMessageEnd()
2066 
    if result.success is not None:
2067 
      return result.success
2068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2069 
 
2070 
  def getCategory(self, id):
2071 
    """
2072 
    Parameters:
2073 
     - id
2074 
    """
2075 
    self.send_getCategory(id)
2076 
    return self.recv_getCategory()
2077 
 
2078 
  def send_getCategory(self, id):
2079 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2080 
    args = getCategory_args()
2081 
    args.id = id
2082 
    args.write(self._oprot)
2083 
    self._oprot.writeMessageEnd()
2084 
    self._oprot.trans.flush()
2085 
 
2086 
  def recv_getCategory(self, ):
2087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2088 
    if mtype == TMessageType.EXCEPTION:
2089 
      x = TApplicationException()
2090 
      x.read(self._iprot)
2091 
      self._iprot.readMessageEnd()
2092 
      raise x
2093 
    result = getCategory_result()
2094 
    result.read(self._iprot)
2095 
    self._iprot.readMessageEnd()
2096 
    if result.success is not None:
2097 
      return result.success
2098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2099 
 
2100 
  def getAllCategories(self, ):
2101 
    self.send_getAllCategories()
2102 
    return self.recv_getAllCategories()
2103 
 
2104 
  def send_getAllCategories(self, ):
2105 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2106 
    args = getAllCategories_args()
2107 
    args.write(self._oprot)
2108 
    self._oprot.writeMessageEnd()
2109 
    self._oprot.trans.flush()
2110 
 
2111 
  def recv_getAllCategories(self, ):
2112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2113 
    if mtype == TMessageType.EXCEPTION:
2114 
      x = TApplicationException()
2115 
      x.read(self._iprot)
2116 
      self._iprot.readMessageEnd()
2117 
      raise x
2118 
    result = getAllCategories_result()
2119 
    result.read(self._iprot)
2120 
    self._iprot.readMessageEnd()
2121 
    if result.success is not None:
2122 
      return result.success
2123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2124 
 
2125 
  def getAllSimilarItems(self, itemId):
2126 
    """
2127 
    Returns the list of similar items.
2128 
 
2129 
    Parameters:
2130 
     - itemId
2131 
    """
2132 
    self.send_getAllSimilarItems(itemId)
2133 
    return self.recv_getAllSimilarItems()
2134 
 
2135 
  def send_getAllSimilarItems(self, itemId):
2136 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2137 
    args = getAllSimilarItems_args()
2138 
    args.itemId = itemId
2139 
    args.write(self._oprot)
2140 
    self._oprot.writeMessageEnd()
2141 
    self._oprot.trans.flush()
2142 
 
2143 
  def recv_getAllSimilarItems(self, ):
2144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2145 
    if mtype == TMessageType.EXCEPTION:
2146 
      x = TApplicationException()
2147 
      x.read(self._iprot)
2148 
      self._iprot.readMessageEnd()
2149 
      raise x
2150 
    result = getAllSimilarItems_result()
2151 
    result.read(self._iprot)
2152 
    self._iprot.readMessageEnd()
2153 
    if result.success is not None:
2154 
      return result.success
2155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2156 
 
2157 
  def addSimilarItem(self, itemId, catalogItemId):
2158 
    """
2159 
    Adds similar item.
2160 
 
2161 
    Parameters:
2162 
     - itemId
2163 
     - catalogItemId
2164 
    """
2165 
    self.send_addSimilarItem(itemId, catalogItemId)
2166 
    return self.recv_addSimilarItem()
2167 
 
2168 
  def send_addSimilarItem(self, itemId, catalogItemId):
2169 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2170 
    args = addSimilarItem_args()
2171 
    args.itemId = itemId
2172 
    args.catalogItemId = catalogItemId
2173 
    args.write(self._oprot)
2174 
    self._oprot.writeMessageEnd()
2175 
    self._oprot.trans.flush()
2176 
 
2177 
  def recv_addSimilarItem(self, ):
2178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2179 
    if mtype == TMessageType.EXCEPTION:
2180 
      x = TApplicationException()
2181 
      x.read(self._iprot)
2182 
      self._iprot.readMessageEnd()
2183 
      raise x
2184 
    result = addSimilarItem_result()
2185 
    result.read(self._iprot)
2186 
    self._iprot.readMessageEnd()
2187 
    if result.success is not None:
2188 
      return result.success
2189 
    if result.cex is not None:
2190 
      raise result.cex
2191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2192 
 
6512 kshitij.so 2193 
  def addTag(self, displayName, itemId):
2194 
    """
2195 
    Tag Related
2196 
 
2197 
    Parameters:
2198 
     - displayName
2199 
     - itemId
2200 
    """
2201 
    self.send_addTag(displayName, itemId)
2202 
    return self.recv_addTag()
2203 
 
2204 
  def send_addTag(self, displayName, itemId):
2205 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2206 
    args = addTag_args()
2207 
    args.displayName = displayName
2208 
    args.itemId = itemId
2209 
    args.write(self._oprot)
2210 
    self._oprot.writeMessageEnd()
2211 
    self._oprot.trans.flush()
2212 
 
2213 
  def recv_addTag(self, ):
2214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2215 
    if mtype == TMessageType.EXCEPTION:
2216 
      x = TApplicationException()
2217 
      x.read(self._iprot)
2218 
      self._iprot.readMessageEnd()
2219 
      raise x
2220 
    result = addTag_result()
2221 
    result.read(self._iprot)
2222 
    self._iprot.readMessageEnd()
2223 
    if result.success is not None:
2224 
      return result.success
2225 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2226 
 
2227 
  def deleteEntityTag(self, displayName, itemId):
2228 
    """
2229 
    Parameters:
2230 
     - displayName
2231 
     - itemId
2232 
    """
2233 
    self.send_deleteEntityTag(displayName, itemId)
2234 
    return self.recv_deleteEntityTag()
2235 
 
2236 
  def send_deleteEntityTag(self, displayName, itemId):
2237 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2238 
    args = deleteEntityTag_args()
2239 
    args.displayName = displayName
2240 
    args.itemId = itemId
2241 
    args.write(self._oprot)
2242 
    self._oprot.writeMessageEnd()
2243 
    self._oprot.trans.flush()
2244 
 
2245 
  def recv_deleteEntityTag(self, ):
2246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2247 
    if mtype == TMessageType.EXCEPTION:
2248 
      x = TApplicationException()
2249 
      x.read(self._iprot)
2250 
      self._iprot.readMessageEnd()
2251 
      raise x
2252 
    result = deleteEntityTag_result()
2253 
    result.read(self._iprot)
2254 
    self._iprot.readMessageEnd()
2255 
    if result.success is not None:
2256 
      return result.success
2257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2258 
 
2259 
  def deleteTag(self, displayName):
2260 
    """
2261 
    Parameters:
2262 
     - displayName
2263 
    """
2264 
    self.send_deleteTag(displayName)
2265 
    return self.recv_deleteTag()
2266 
 
2267 
  def send_deleteTag(self, displayName):
2268 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2269 
    args = deleteTag_args()
2270 
    args.displayName = displayName
2271 
    args.write(self._oprot)
2272 
    self._oprot.writeMessageEnd()
2273 
    self._oprot.trans.flush()
2274 
 
2275 
  def recv_deleteTag(self, ):
2276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2277 
    if mtype == TMessageType.EXCEPTION:
2278 
      x = TApplicationException()
2279 
      x.read(self._iprot)
2280 
      self._iprot.readMessageEnd()
2281 
      raise x
2282 
    result = deleteTag_result()
2283 
    result.read(self._iprot)
2284 
    self._iprot.readMessageEnd()
2285 
    if result.success is not None:
2286 
      return result.success
2287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2288 
 
2289 
  def getAllTags(self, ):
2290 
    self.send_getAllTags()
2291 
    return self.recv_getAllTags()
2292 
 
2293 
  def send_getAllTags(self, ):
2294 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2295 
    args = getAllTags_args()
2296 
    args.write(self._oprot)
2297 
    self._oprot.writeMessageEnd()
2298 
    self._oprot.trans.flush()
2299 
 
2300 
  def recv_getAllTags(self, ):
2301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2302 
    if mtype == TMessageType.EXCEPTION:
2303 
      x = TApplicationException()
2304 
      x.read(self._iprot)
2305 
      self._iprot.readMessageEnd()
2306 
      raise x
2307 
    result = getAllTags_result()
2308 
    result.read(self._iprot)
2309 
    self._iprot.readMessageEnd()
2310 
    if result.success is not None:
2311 
      return result.success
2312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2313 
 
2314 
  def getAllEntitiesByTagName(self, displayName):
2315 
    """
2316 
    Parameters:
2317 
     - displayName
2318 
    """
2319 
    self.send_getAllEntitiesByTagName(displayName)
2320 
    return self.recv_getAllEntitiesByTagName()
2321 
 
2322 
  def send_getAllEntitiesByTagName(self, displayName):
2323 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2324 
    args = getAllEntitiesByTagName_args()
2325 
    args.displayName = displayName
2326 
    args.write(self._oprot)
2327 
    self._oprot.writeMessageEnd()
2328 
    self._oprot.trans.flush()
2329 
 
2330 
  def recv_getAllEntitiesByTagName(self, ):
2331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2332 
    if mtype == TMessageType.EXCEPTION:
2333 
      x = TApplicationException()
2334 
      x.read(self._iprot)
2335 
      self._iprot.readMessageEnd()
2336 
      raise x
2337 
    result = getAllEntitiesByTagName_result()
2338 
    result.read(self._iprot)
2339 
    self._iprot.readMessageEnd()
2340 
    if result.success is not None:
2341 
      return result.success
2342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2343 
 
6845 amit.gupta 2344 
  def getAllEntityTags(self, ):
2345 
    self.send_getAllEntityTags()
2346 
    return self.recv_getAllEntityTags()
2347 
 
2348 
  def send_getAllEntityTags(self, ):
2349 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2350 
    args = getAllEntityTags_args()
2351 
    args.write(self._oprot)
2352 
    self._oprot.writeMessageEnd()
2353 
    self._oprot.trans.flush()
2354 
 
2355 
  def recv_getAllEntityTags(self, ):
2356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2357 
    if mtype == TMessageType.EXCEPTION:
2358 
      x = TApplicationException()
2359 
      x.read(self._iprot)
2360 
      self._iprot.readMessageEnd()
2361 
      raise x
2362 
    result = getAllEntityTags_result()
2363 
    result.read(self._iprot)
2364 
    self._iprot.readMessageEnd()
2365 
    if result.success is not None:
2366 
      return result.success
2367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2368 
 
8590 kshitij.so 2369 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2370 
    """
8579 kshitij.so 2371 
    Banner Related
2372 
 
6850 kshitij.so 2373 
    Parameters:
8590 kshitij.so 2374 
     - bannerCongregate
6850 kshitij.so 2375 
    """
8590 kshitij.so 2376 
    self.send_addBanner(bannerCongregate)
2377 
    self.recv_addBanner()
6850 kshitij.so 2378 
 
8590 kshitij.so 2379 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2380 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2381 
    args = addBanner_args()
8590 kshitij.so 2382 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2383 
    args.write(self._oprot)
2384 
    self._oprot.writeMessageEnd()
2385 
    self._oprot.trans.flush()
2386 
 
2387 
  def recv_addBanner(self, ):
2388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2389 
    if mtype == TMessageType.EXCEPTION:
2390 
      x = TApplicationException()
2391 
      x.read(self._iprot)
2392 
      self._iprot.readMessageEnd()
2393 
      raise x
2394 
    result = addBanner_result()
2395 
    result.read(self._iprot)
2396 
    self._iprot.readMessageEnd()
8590 kshitij.so 2397 
    return
6850 kshitij.so 2398 
 
8579 kshitij.so 2399 
  def updateBanner(self, banner):
2400 
    """
2401 
    Parameters:
2402 
     - banner
2403 
    """
2404 
    self.send_updateBanner(banner)
2405 
    return self.recv_updateBanner()
2406 
 
2407 
  def send_updateBanner(self, banner):
2408 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2409 
    args = updateBanner_args()
2410 
    args.banner = banner
2411 
    args.write(self._oprot)
2412 
    self._oprot.writeMessageEnd()
2413 
    self._oprot.trans.flush()
2414 
 
2415 
  def recv_updateBanner(self, ):
2416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2417 
    if mtype == TMessageType.EXCEPTION:
2418 
      x = TApplicationException()
2419 
      x.read(self._iprot)
2420 
      self._iprot.readMessageEnd()
2421 
      raise x
2422 
    result = updateBanner_result()
2423 
    result.read(self._iprot)
2424 
    self._iprot.readMessageEnd()
2425 
    if result.success is not None:
2426 
      return result.success
2427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2428 
 
6850 kshitij.so 2429 
  def getAllBanners(self, ):
2430 
    self.send_getAllBanners()
2431 
    return self.recv_getAllBanners()
2432 
 
2433 
  def send_getAllBanners(self, ):
2434 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2435 
    args = getAllBanners_args()
2436 
    args.write(self._oprot)
2437 
    self._oprot.writeMessageEnd()
2438 
    self._oprot.trans.flush()
2439 
 
2440 
  def recv_getAllBanners(self, ):
2441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2442 
    if mtype == TMessageType.EXCEPTION:
2443 
      x = TApplicationException()
2444 
      x.read(self._iprot)
2445 
      self._iprot.readMessageEnd()
2446 
      raise x
2447 
    result = getAllBanners_result()
2448 
    result.read(self._iprot)
2449 
    self._iprot.readMessageEnd()
2450 
    if result.success is not None:
2451 
      return result.success
2452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2453 
 
9155 kshitij.so 2454 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2455 
    """
2456 
    Parameters:
2457 
     - bannerName
9155 kshitij.so 2458 
     - bannerType
6850 kshitij.so 2459 
    """
9155 kshitij.so 2460 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2461 
    return self.recv_deleteBanner()
2462 
 
9155 kshitij.so 2463 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2464 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2465 
    args = deleteBanner_args()
2466 
    args.bannerName = bannerName
9155 kshitij.so 2467 
    args.bannerType = bannerType
6850 kshitij.so 2468 
    args.write(self._oprot)
2469 
    self._oprot.writeMessageEnd()
2470 
    self._oprot.trans.flush()
2471 
 
2472 
  def recv_deleteBanner(self, ):
2473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2474 
    if mtype == TMessageType.EXCEPTION:
2475 
      x = TApplicationException()
2476 
      x.read(self._iprot)
2477 
      self._iprot.readMessageEnd()
2478 
      raise x
2479 
    result = deleteBanner_result()
2480 
    result.read(self._iprot)
2481 
    self._iprot.readMessageEnd()
2482 
    if result.success is not None:
2483 
      return result.success
2484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2485 
 
9155 kshitij.so 2486 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2487 
    """
2488 
    Parameters:
2489 
     - bannerName
9155 kshitij.so 2490 
     - bannerType
6850 kshitij.so 2491 
    """
9155 kshitij.so 2492 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2493 
    return self.recv_getBannerDetails()
2494 
 
9155 kshitij.so 2495 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2496 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2497 
    args = getBannerDetails_args()
2498 
    args.bannerName = bannerName
9155 kshitij.so 2499 
    args.bannerType = bannerType
6850 kshitij.so 2500 
    args.write(self._oprot)
2501 
    self._oprot.writeMessageEnd()
2502 
    self._oprot.trans.flush()
2503 
 
2504 
  def recv_getBannerDetails(self, ):
2505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2506 
    if mtype == TMessageType.EXCEPTION:
2507 
      x = TApplicationException()
2508 
      x.read(self._iprot)
2509 
      self._iprot.readMessageEnd()
2510 
      raise x
2511 
    result = getBannerDetails_result()
2512 
    result.read(self._iprot)
2513 
    self._iprot.readMessageEnd()
2514 
    if result.success is not None:
2515 
      return result.success
2516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2517 
 
2518 
  def getActiveBanners(self, ):
2519 
    self.send_getActiveBanners()
2520 
    return self.recv_getActiveBanners()
2521 
 
2522 
  def send_getActiveBanners(self, ):
2523 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2524 
    args = getActiveBanners_args()
2525 
    args.write(self._oprot)
2526 
    self._oprot.writeMessageEnd()
2527 
    self._oprot.trans.flush()
2528 
 
2529 
  def recv_getActiveBanners(self, ):
2530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2531 
    if mtype == TMessageType.EXCEPTION:
2532 
      x = TApplicationException()
2533 
      x.read(self._iprot)
2534 
      self._iprot.readMessageEnd()
2535 
      raise x
2536 
    result = getActiveBanners_result()
2537 
    result.read(self._iprot)
2538 
    self._iprot.readMessageEnd()
2539 
    if result.success is not None:
2540 
      return result.success
2541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2542 
 
8579 kshitij.so 2543 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2544 
    """
2545 
    Parameters:
8579 kshitij.so 2546 
     - bannerMaps
6849 kshitij.so 2547 
    """
8579 kshitij.so 2548 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2549 
    return self.recv_addBannerMap()
2550 
 
8579 kshitij.so 2551 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2552 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2553 
    args = addBannerMap_args()
8579 kshitij.so 2554 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2555 
    args.write(self._oprot)
2556 
    self._oprot.writeMessageEnd()
2557 
    self._oprot.trans.flush()
2558 
 
2559 
  def recv_addBannerMap(self, ):
2560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2561 
    if mtype == TMessageType.EXCEPTION:
2562 
      x = TApplicationException()
2563 
      x.read(self._iprot)
2564 
      self._iprot.readMessageEnd()
2565 
      raise x
2566 
    result = addBannerMap_result()
2567 
    result.read(self._iprot)
2568 
    self._iprot.readMessageEnd()
2569 
    if result.success is not None:
2570 
      return result.success
2571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2572 
 
8579 kshitij.so 2573 
  def updateBannerMap(self, bannerMap):
2574 
    """
2575 
    Parameters:
2576 
     - bannerMap
2577 
    """
2578 
    self.send_updateBannerMap(bannerMap)
2579 
    return self.recv_updateBannerMap()
2580 
 
2581 
  def send_updateBannerMap(self, bannerMap):
2582 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2583 
    args = updateBannerMap_args()
2584 
    args.bannerMap = bannerMap
2585 
    args.write(self._oprot)
2586 
    self._oprot.writeMessageEnd()
2587 
    self._oprot.trans.flush()
2588 
 
2589 
  def recv_updateBannerMap(self, ):
2590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2591 
    if mtype == TMessageType.EXCEPTION:
2592 
      x = TApplicationException()
2593 
      x.read(self._iprot)
2594 
      self._iprot.readMessageEnd()
2595 
      raise x
2596 
    result = updateBannerMap_result()
2597 
    result.read(self._iprot)
2598 
    self._iprot.readMessageEnd()
2599 
    if result.success is not None:
2600 
      return result.success
2601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2602 
 
6849 kshitij.so 2603 
  def deleteBannerMap(self, bannerName):
2604 
    """
2605 
    Parameters:
2606 
     - bannerName
2607 
    """
2608 
    self.send_deleteBannerMap(bannerName)
2609 
    return self.recv_deleteBannerMap()
2610 
 
2611 
  def send_deleteBannerMap(self, bannerName):
2612 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2613 
    args = deleteBannerMap_args()
2614 
    args.bannerName = bannerName
2615 
    args.write(self._oprot)
2616 
    self._oprot.writeMessageEnd()
2617 
    self._oprot.trans.flush()
2618 
 
2619 
  def recv_deleteBannerMap(self, ):
2620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2621 
    if mtype == TMessageType.EXCEPTION:
2622 
      x = TApplicationException()
2623 
      x.read(self._iprot)
2624 
      self._iprot.readMessageEnd()
2625 
      raise x
2626 
    result = deleteBannerMap_result()
2627 
    result.read(self._iprot)
2628 
    self._iprot.readMessageEnd()
2629 
    if result.success is not None:
2630 
      return result.success
2631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2632 
 
9155 kshitij.so 2633 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2634 
    """
2635 
    Parameters:
2636 
     - bannerName
9155 kshitij.so 2637 
     - bannerType
6849 kshitij.so 2638 
    """
9155 kshitij.so 2639 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2640 
    return self.recv_getBannerMapDetails()
2641 
 
9155 kshitij.so 2642 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2643 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2644 
    args = getBannerMapDetails_args()
2645 
    args.bannerName = bannerName
9155 kshitij.so 2646 
    args.bannerType = bannerType
6849 kshitij.so 2647 
    args.write(self._oprot)
2648 
    self._oprot.writeMessageEnd()
2649 
    self._oprot.trans.flush()
2650 
 
2651 
  def recv_getBannerMapDetails(self, ):
2652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2653 
    if mtype == TMessageType.EXCEPTION:
2654 
      x = TApplicationException()
2655 
      x.read(self._iprot)
2656 
      self._iprot.readMessageEnd()
2657 
      raise x
2658 
    result = getBannerMapDetails_result()
2659 
    result.read(self._iprot)
2660 
    self._iprot.readMessageEnd()
2661 
    if result.success is not None:
2662 
      return result.success
2663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2664 
 
8579 kshitij.so 2665 
  def addBannerUri(self, bannerUriMappings):
2666 
    """
2667 
    Parameters:
2668 
     - bannerUriMappings
2669 
    """
2670 
    self.send_addBannerUri(bannerUriMappings)
2671 
    self.recv_addBannerUri()
2672 
 
2673 
  def send_addBannerUri(self, bannerUriMappings):
2674 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2675 
    args = addBannerUri_args()
2676 
    args.bannerUriMappings = bannerUriMappings
2677 
    args.write(self._oprot)
2678 
    self._oprot.writeMessageEnd()
2679 
    self._oprot.trans.flush()
2680 
 
2681 
  def recv_addBannerUri(self, ):
2682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2683 
    if mtype == TMessageType.EXCEPTION:
2684 
      x = TApplicationException()
2685 
      x.read(self._iprot)
2686 
      self._iprot.readMessageEnd()
2687 
      raise x
2688 
    result = addBannerUri_result()
2689 
    result.read(self._iprot)
2690 
    self._iprot.readMessageEnd()
2691 
    return
2692 
 
9155 kshitij.so 2693 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2694 
    """
2695 
    Parameters:
2696 
     - bannerName
9155 kshitij.so 2697 
     - bannerType
8579 kshitij.so 2698 
    """
9155 kshitij.so 2699 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2700 
    return self.recv_getUriMapping()
2701 
 
9155 kshitij.so 2702 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2703 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2704 
    args = getUriMapping_args()
2705 
    args.bannerName = bannerName
9155 kshitij.so 2706 
    args.bannerType = bannerType
8579 kshitij.so 2707 
    args.write(self._oprot)
2708 
    self._oprot.writeMessageEnd()
2709 
    self._oprot.trans.flush()
2710 
 
2711 
  def recv_getUriMapping(self, ):
2712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2713 
    if mtype == TMessageType.EXCEPTION:
2714 
      x = TApplicationException()
2715 
      x.read(self._iprot)
2716 
      self._iprot.readMessageEnd()
2717 
      raise x
2718 
    result = getUriMapping_result()
2719 
    result.read(self._iprot)
2720 
    self._iprot.readMessageEnd()
2721 
    if result.success is not None:
2722 
      return result.success
2723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2724 
 
2725 
  def addCampaign(self, campaign):
2726 
    """
2727 
    Parameters:
2728 
     - campaign
2729 
    """
2730 
    self.send_addCampaign(campaign)
2731 
    self.recv_addCampaign()
2732 
 
2733 
  def send_addCampaign(self, campaign):
2734 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2735 
    args = addCampaign_args()
2736 
    args.campaign = campaign
2737 
    args.write(self._oprot)
2738 
    self._oprot.writeMessageEnd()
2739 
    self._oprot.trans.flush()
2740 
 
2741 
  def recv_addCampaign(self, ):
2742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2743 
    if mtype == TMessageType.EXCEPTION:
2744 
      x = TApplicationException()
2745 
      x.read(self._iprot)
2746 
      self._iprot.readMessageEnd()
2747 
      raise x
2748 
    result = addCampaign_result()
2749 
    result.read(self._iprot)
2750 
    self._iprot.readMessageEnd()
2751 
    return
2752 
 
2753 
  def getCampaigns(self, campaignName):
2754 
    """
2755 
    Parameters:
2756 
     - campaignName
2757 
    """
2758 
    self.send_getCampaigns(campaignName)
2759 
    return self.recv_getCampaigns()
2760 
 
2761 
  def send_getCampaigns(self, campaignName):
2762 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2763 
    args = getCampaigns_args()
2764 
    args.campaignName = campaignName
2765 
    args.write(self._oprot)
2766 
    self._oprot.writeMessageEnd()
2767 
    self._oprot.trans.flush()
2768 
 
2769 
  def recv_getCampaigns(self, ):
2770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2771 
    if mtype == TMessageType.EXCEPTION:
2772 
      x = TApplicationException()
2773 
      x.read(self._iprot)
2774 
      self._iprot.readMessageEnd()
2775 
      raise x
2776 
    result = getCampaigns_result()
2777 
    result.read(self._iprot)
2778 
    self._iprot.readMessageEnd()
2779 
    if result.success is not None:
2780 
      return result.success
2781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2782 
 
2783 
  def deleteCampaign(self, campaignId):
2784 
    """
2785 
    Parameters:
2786 
     - campaignId
2787 
    """
2788 
    self.send_deleteCampaign(campaignId)
2789 
    self.recv_deleteCampaign()
2790 
 
2791 
  def send_deleteCampaign(self, campaignId):
2792 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2793 
    args = deleteCampaign_args()
2794 
    args.campaignId = campaignId
2795 
    args.write(self._oprot)
2796 
    self._oprot.writeMessageEnd()
2797 
    self._oprot.trans.flush()
2798 
 
2799 
  def recv_deleteCampaign(self, ):
2800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2801 
    if mtype == TMessageType.EXCEPTION:
2802 
      x = TApplicationException()
2803 
      x.read(self._iprot)
2804 
      self._iprot.readMessageEnd()
2805 
      raise x
2806 
    result = deleteCampaign_result()
2807 
    result.read(self._iprot)
2808 
    self._iprot.readMessageEnd()
2809 
    return
2810 
 
2811 
  def getAllCampaigns(self, ):
2812 
    self.send_getAllCampaigns()
2813 
    return self.recv_getAllCampaigns()
2814 
 
2815 
  def send_getAllCampaigns(self, ):
2816 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2817 
    args = getAllCampaigns_args()
2818 
    args.write(self._oprot)
2819 
    self._oprot.writeMessageEnd()
2820 
    self._oprot.trans.flush()
2821 
 
2822 
  def recv_getAllCampaigns(self, ):
2823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2824 
    if mtype == TMessageType.EXCEPTION:
2825 
      x = TApplicationException()
2826 
      x.read(self._iprot)
2827 
      self._iprot.readMessageEnd()
2828 
      raise x
2829 
    result = getAllCampaigns_result()
2830 
    result.read(self._iprot)
2831 
    self._iprot.readMessageEnd()
2832 
    if result.success is not None:
2833 
      return result.success
2834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2835 
 
9155 kshitij.so 2836 
  def getActiveBannersForMobileSite(self, ):
2837 
    self.send_getActiveBannersForMobileSite()
2838 
    return self.recv_getActiveBannersForMobileSite()
2839 
 
2840 
  def send_getActiveBannersForMobileSite(self, ):
2841 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2842 
    args = getActiveBannersForMobileSite_args()
2843 
    args.write(self._oprot)
2844 
    self._oprot.writeMessageEnd()
2845 
    self._oprot.trans.flush()
2846 
 
2847 
  def recv_getActiveBannersForMobileSite(self, ):
2848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2849 
    if mtype == TMessageType.EXCEPTION:
2850 
      x = TApplicationException()
2851 
      x.read(self._iprot)
2852 
      self._iprot.readMessageEnd()
2853 
      raise x
2854 
    result = getActiveBannersForMobileSite_result()
2855 
    result.read(self._iprot)
2856 
    self._iprot.readMessageEnd()
2857 
    if result.success is not None:
2858 
      return result.success
2859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2860 
 
5944 mandeep.dh 2861 
  def deleteSimilarItem(self, itemId, catalogItemId):
2862 
    """
2863 
    Delete similar item.
2864 
 
2865 
    Parameters:
2866 
     - itemId
2867 
     - catalogItemId
2868 
    """
2869 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2870 
    return self.recv_deleteSimilarItem()
2871 
 
2872 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2873 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2874 
    args = deleteSimilarItem_args()
2875 
    args.itemId = itemId
2876 
    args.catalogItemId = catalogItemId
2877 
    args.write(self._oprot)
2878 
    self._oprot.writeMessageEnd()
2879 
    self._oprot.trans.flush()
2880 
 
2881 
  def recv_deleteSimilarItem(self, ):
2882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2883 
    if mtype == TMessageType.EXCEPTION:
2884 
      x = TApplicationException()
2885 
      x.read(self._iprot)
2886 
      self._iprot.readMessageEnd()
2887 
      raise x
2888 
    result = deleteSimilarItem_result()
2889 
    result.read(self._iprot)
2890 
    self._iprot.readMessageEnd()
2891 
    if result.success is not None:
2892 
      return result.success
2893 
    if result.cex is not None:
2894 
      raise result.cex
2895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2896 
 
2897 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2898 
    """
2899 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2900 
    If yes, returns the itemId else returns 0
2901 
 
2902 
    Parameters:
2903 
     - brand
2904 
     - modelNumber
2905 
     - modelName
2906 
     - color
2907 
    """
2908 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2909 
    return self.recv_checkSimilarItem()
2910 
 
2911 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2912 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2913 
    args = checkSimilarItem_args()
2914 
    args.brand = brand
2915 
    args.modelNumber = modelNumber
2916 
    args.modelName = modelName
2917 
    args.color = color
2918 
    args.write(self._oprot)
2919 
    self._oprot.writeMessageEnd()
2920 
    self._oprot.trans.flush()
2921 
 
2922 
  def recv_checkSimilarItem(self, ):
2923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2924 
    if mtype == TMessageType.EXCEPTION:
2925 
      x = TApplicationException()
2926 
      x.read(self._iprot)
2927 
      self._iprot.readMessageEnd()
2928 
      raise x
2929 
    result = checkSimilarItem_result()
2930 
    result.read(self._iprot)
2931 
    self._iprot.readMessageEnd()
2932 
    if result.success is not None:
2933 
      return result.success
2934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2935 
 
2936 
  def validateRiskyStatus(self, itemId):
2937 
    """
2938 
    Check wether item is risky and change status if inventory is not available for risky items
2939 
 
2940 
    Parameters:
2941 
     - itemId
2942 
    """
2943 
    self.send_validateRiskyStatus(itemId)
2944 
    self.recv_validateRiskyStatus()
2945 
 
2946 
  def send_validateRiskyStatus(self, itemId):
2947 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2948 
    args = validateRiskyStatus_args()
2949 
    args.itemId = itemId
2950 
    args.write(self._oprot)
2951 
    self._oprot.writeMessageEnd()
2952 
    self._oprot.trans.flush()
2953 
 
2954 
  def recv_validateRiskyStatus(self, ):
2955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2956 
    if mtype == TMessageType.EXCEPTION:
2957 
      x = TApplicationException()
2958 
      x.read(self._iprot)
2959 
      self._iprot.readMessageEnd()
2960 
      raise x
2961 
    result = validateRiskyStatus_result()
2962 
    result.read(self._iprot)
2963 
    self._iprot.readMessageEnd()
2964 
    return
2965 
 
2966 
  def changeItemRiskyFlag(self, itemId, risky):
2967 
    """
2968 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2969 
 
2970 
    Parameters:
2971 
     - itemId
2972 
     - risky
2973 
    """
2974 
    self.send_changeItemRiskyFlag(itemId, risky)
2975 
    self.recv_changeItemRiskyFlag()
2976 
 
2977 
  def send_changeItemRiskyFlag(self, itemId, risky):
2978 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2979 
    args = changeItemRiskyFlag_args()
2980 
    args.itemId = itemId
2981 
    args.risky = risky
2982 
    args.write(self._oprot)
2983 
    self._oprot.writeMessageEnd()
2984 
    self._oprot.trans.flush()
2985 
 
2986 
  def recv_changeItemRiskyFlag(self, ):
2987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2988 
    if mtype == TMessageType.EXCEPTION:
2989 
      x = TApplicationException()
2990 
      x.read(self._iprot)
2991 
      self._iprot.readMessageEnd()
2992 
      raise x
2993 
    result = changeItemRiskyFlag_result()
2994 
    result.read(self._iprot)
2995 
    self._iprot.readMessageEnd()
2996 
    return
2997 
 
2998 
  def getItemsByRiskyFlag(self, ):
2999 
    """
3000 
    Returns list of items marked as risky.
3001 
    """
3002 
    self.send_getItemsByRiskyFlag()
3003 
    return self.recv_getItemsByRiskyFlag()
3004 
 
3005 
  def send_getItemsByRiskyFlag(self, ):
3006 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
3007 
    args = getItemsByRiskyFlag_args()
3008 
    args.write(self._oprot)
3009 
    self._oprot.writeMessageEnd()
3010 
    self._oprot.trans.flush()
3011 
 
3012 
  def recv_getItemsByRiskyFlag(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 = getItemsByRiskyFlag_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, "getItemsByRiskyFlag failed: unknown result");
3025 
 
3026 
  def getItemsForMasterSheet(self, category, brand):
3027 
    """
3028 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3029 
 
3030 
    Parameters:
3031 
     - category
3032 
     - brand
3033 
    """
3034 
    self.send_getItemsForMasterSheet(category, brand)
3035 
    return self.recv_getItemsForMasterSheet()
3036 
 
3037 
  def send_getItemsForMasterSheet(self, category, brand):
3038 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3039 
    args = getItemsForMasterSheet_args()
3040 
    args.category = category
3041 
    args.brand = brand
3042 
    args.write(self._oprot)
3043 
    self._oprot.writeMessageEnd()
3044 
    self._oprot.trans.flush()
3045 
 
3046 
  def recv_getItemsForMasterSheet(self, ):
3047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3048 
    if mtype == TMessageType.EXCEPTION:
3049 
      x = TApplicationException()
3050 
      x.read(self._iprot)
3051 
      self._iprot.readMessageEnd()
3052 
      raise x
3053 
    result = getItemsForMasterSheet_result()
3054 
    result.read(self._iprot)
3055 
    self._iprot.readMessageEnd()
3056 
    if result.success is not None:
3057 
      return result.success
3058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3059 
 
3060 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3061 
    """
3062 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3063 
 
3064 
    Parameters:
3065 
     - beginIndex
3066 
     - totalItems
3067 
     - itemId
3068 
    """
3069 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3070 
    return self.recv_getSimilarItemsCatalogIds()
3071 
 
3072 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3073 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3074 
    args = getSimilarItemsCatalogIds_args()
3075 
    args.beginIndex = beginIndex
3076 
    args.totalItems = totalItems
3077 
    args.itemId = itemId
3078 
    args.write(self._oprot)
3079 
    self._oprot.writeMessageEnd()
3080 
    self._oprot.trans.flush()
3081 
 
3082 
  def recv_getSimilarItemsCatalogIds(self, ):
3083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3084 
    if mtype == TMessageType.EXCEPTION:
3085 
      x = TApplicationException()
3086 
      x.read(self._iprot)
3087 
      self._iprot.readMessageEnd()
3088 
      raise x
3089 
    result = getSimilarItemsCatalogIds_result()
3090 
    result.read(self._iprot)
3091 
    self._iprot.readMessageEnd()
3092 
    if result.success is not None:
3093 
      return result.success
3094 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3095 
 
3096 
  def addProductNotification(self, itemId, email):
3097 
    """
3098 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3099 
 
3100 
    Parameters:
3101 
     - itemId
3102 
     - email
3103 
    """
3104 
    self.send_addProductNotification(itemId, email)
3105 
    return self.recv_addProductNotification()
3106 
 
3107 
  def send_addProductNotification(self, itemId, email):
3108 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3109 
    args = addProductNotification_args()
3110 
    args.itemId = itemId
3111 
    args.email = email
3112 
    args.write(self._oprot)
3113 
    self._oprot.writeMessageEnd()
3114 
    self._oprot.trans.flush()
3115 
 
3116 
  def recv_addProductNotification(self, ):
3117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3118 
    if mtype == TMessageType.EXCEPTION:
3119 
      x = TApplicationException()
3120 
      x.read(self._iprot)
3121 
      self._iprot.readMessageEnd()
3122 
      raise x
3123 
    result = addProductNotification_result()
3124 
    result.read(self._iprot)
3125 
    self._iprot.readMessageEnd()
3126 
    if result.success is not None:
3127 
      return result.success
3128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3129 
 
3130 
  def sendProductNotifications(self, ):
3131 
    """
3132 
    Send the product notifications to the users for items which has stock.
3133 
    """
3134 
    self.send_sendProductNotifications()
3135 
    return self.recv_sendProductNotifications()
3136 
 
3137 
  def send_sendProductNotifications(self, ):
3138 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3139 
    args = sendProductNotifications_args()
3140 
    args.write(self._oprot)
3141 
    self._oprot.writeMessageEnd()
3142 
    self._oprot.trans.flush()
3143 
 
3144 
  def recv_sendProductNotifications(self, ):
3145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3146 
    if mtype == TMessageType.EXCEPTION:
3147 
      x = TApplicationException()
3148 
      x.read(self._iprot)
3149 
      self._iprot.readMessageEnd()
3150 
      raise x
3151 
    result = sendProductNotifications_result()
3152 
    result.read(self._iprot)
3153 
    self._iprot.readMessageEnd()
3154 
    if result.success is not None:
3155 
      return result.success
3156 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3157 
 
3158 
  def getAllBrandsByCategory(self, categoryId):
3159 
    """
3160 
    Returns list of brand names for a given category Id
3161 
 
3162 
    Parameters:
3163 
     - categoryId
3164 
    """
3165 
    self.send_getAllBrandsByCategory(categoryId)
3166 
    return self.recv_getAllBrandsByCategory()
3167 
 
3168 
  def send_getAllBrandsByCategory(self, categoryId):
3169 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3170 
    args = getAllBrandsByCategory_args()
3171 
    args.categoryId = categoryId
3172 
    args.write(self._oprot)
3173 
    self._oprot.writeMessageEnd()
3174 
    self._oprot.trans.flush()
3175 
 
3176 
  def recv_getAllBrandsByCategory(self, ):
3177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3178 
    if mtype == TMessageType.EXCEPTION:
3179 
      x = TApplicationException()
3180 
      x.read(self._iprot)
3181 
      self._iprot.readMessageEnd()
3182 
      raise x
3183 
    result = getAllBrandsByCategory_result()
3184 
    result.read(self._iprot)
3185 
    self._iprot.readMessageEnd()
3186 
    if result.success is not None:
3187 
      return result.success
3188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3189 
 
3190 
  def getAllBrands(self, ):
3191 
    """
3192 
    Returns list of brand names
3193 
    """
3194 
    self.send_getAllBrands()
3195 
    return self.recv_getAllBrands()
3196 
 
3197 
  def send_getAllBrands(self, ):
3198 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3199 
    args = getAllBrands_args()
3200 
    args.write(self._oprot)
3201 
    self._oprot.writeMessageEnd()
3202 
    self._oprot.trans.flush()
3203 
 
3204 
  def recv_getAllBrands(self, ):
3205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3206 
    if mtype == TMessageType.EXCEPTION:
3207 
      x = TApplicationException()
3208 
      x.read(self._iprot)
3209 
      self._iprot.readMessageEnd()
3210 
      raise x
3211 
    result = getAllBrands_result()
3212 
    result.read(self._iprot)
3213 
    self._iprot.readMessageEnd()
3214 
    if result.success is not None:
3215 
      return result.success
3216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3217 
 
3218 
  def getAllSources(self, ):
3219 
    """
3220 
    Return list of all sources
3221 
    """
3222 
    self.send_getAllSources()
3223 
    return self.recv_getAllSources()
3224 
 
3225 
  def send_getAllSources(self, ):
3226 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3227 
    args = getAllSources_args()
3228 
    args.write(self._oprot)
3229 
    self._oprot.writeMessageEnd()
3230 
    self._oprot.trans.flush()
3231 
 
3232 
  def recv_getAllSources(self, ):
3233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3234 
    if mtype == TMessageType.EXCEPTION:
3235 
      x = TApplicationException()
3236 
      x.read(self._iprot)
3237 
      self._iprot.readMessageEnd()
3238 
      raise x
3239 
    result = getAllSources_result()
3240 
    result.read(self._iprot)
3241 
    self._iprot.readMessageEnd()
3242 
    if result.success is not None:
3243 
      return result.success
3244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3245 
 
3246 
  def getItemPricingBySource(self, itemId, sourceId):
3247 
    """
3248 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3249 
 
3250 
    Parameters:
3251 
     - itemId
3252 
     - sourceId
3253 
    """
3254 
    self.send_getItemPricingBySource(itemId, sourceId)
3255 
    return self.recv_getItemPricingBySource()
3256 
 
3257 
  def send_getItemPricingBySource(self, itemId, sourceId):
3258 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3259 
    args = getItemPricingBySource_args()
3260 
    args.itemId = itemId
3261 
    args.sourceId = sourceId
3262 
    args.write(self._oprot)
3263 
    self._oprot.writeMessageEnd()
3264 
    self._oprot.trans.flush()
3265 
 
3266 
  def recv_getItemPricingBySource(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 = getItemPricingBySource_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, "getItemPricingBySource failed: unknown result");
3281 
 
3282 
  def addSourceItemPricing(self, sourceItemPricing):
3283 
    """
3284 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3285 
    If item is not found or source is not found, it will throw exception.
3286 
 
3287 
    Parameters:
3288 
     - sourceItemPricing
3289 
    """
3290 
    self.send_addSourceItemPricing(sourceItemPricing)
3291 
    self.recv_addSourceItemPricing()
3292 
 
3293 
  def send_addSourceItemPricing(self, sourceItemPricing):
3294 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3295 
    args = addSourceItemPricing_args()
3296 
    args.sourceItemPricing = sourceItemPricing
3297 
    args.write(self._oprot)
3298 
    self._oprot.writeMessageEnd()
3299 
    self._oprot.trans.flush()
3300 
 
3301 
  def recv_addSourceItemPricing(self, ):
3302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3303 
    if mtype == TMessageType.EXCEPTION:
3304 
      x = TApplicationException()
3305 
      x.read(self._iprot)
3306 
      self._iprot.readMessageEnd()
3307 
      raise x
3308 
    result = addSourceItemPricing_result()
3309 
    result.read(self._iprot)
3310 
    self._iprot.readMessageEnd()
3311 
    if result.cex is not None:
3312 
      raise result.cex
3313 
    return
3314 
 
3315 
  def getAllSourcePricing(self, itemId):
3316 
    """
3317 
    Returns the list of source pricing information of an item.
3318 
    Raises an exception if item not found corresponding to itemId
3319 
 
3320 
    Parameters:
3321 
     - itemId
3322 
    """
3323 
    self.send_getAllSourcePricing(itemId)
3324 
    return self.recv_getAllSourcePricing()
3325 
 
3326 
  def send_getAllSourcePricing(self, itemId):
3327 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3328 
    args = getAllSourcePricing_args()
3329 
    args.itemId = itemId
3330 
    args.write(self._oprot)
3331 
    self._oprot.writeMessageEnd()
3332 
    self._oprot.trans.flush()
3333 
 
3334 
  def recv_getAllSourcePricing(self, ):
3335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3336 
    if mtype == TMessageType.EXCEPTION:
3337 
      x = TApplicationException()
3338 
      x.read(self._iprot)
3339 
      self._iprot.readMessageEnd()
3340 
      raise x
3341 
    result = getAllSourcePricing_result()
3342 
    result.read(self._iprot)
3343 
    self._iprot.readMessageEnd()
3344 
    if result.success is not None:
3345 
      return result.success
3346 
    if result.cex is not None:
3347 
      raise result.cex
3348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3349 
 
3350 
  def getItemForSource(self, item_id, sourceId):
3351 
    """
3352 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3353 
 
3354 
    Parameters:
3355 
     - item_id
3356 
     - sourceId
3357 
    """
3358 
    self.send_getItemForSource(item_id, sourceId)
3359 
    return self.recv_getItemForSource()
3360 
 
3361 
  def send_getItemForSource(self, item_id, sourceId):
3362 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3363 
    args = getItemForSource_args()
3364 
    args.item_id = item_id
3365 
    args.sourceId = sourceId
3366 
    args.write(self._oprot)
3367 
    self._oprot.writeMessageEnd()
3368 
    self._oprot.trans.flush()
3369 
 
3370 
  def recv_getItemForSource(self, ):
3371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3372 
    if mtype == TMessageType.EXCEPTION:
3373 
      x = TApplicationException()
3374 
      x.read(self._iprot)
3375 
      self._iprot.readMessageEnd()
3376 
      raise x
3377 
    result = getItemForSource_result()
3378 
    result.read(self._iprot)
3379 
    self._iprot.readMessageEnd()
3380 
    if result.success is not None:
3381 
      return result.success
3382 
    if result.cex is not None:
3383 
      raise result.cex
3384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3385 
 
3386 
  def searchItemsInRange(self, searchTerms, offset, limit):
3387 
    """
3388 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3389 
 
3390 
    Parameters:
3391 
     - searchTerms
3392 
     - offset
3393 
     - limit
3394 
    """
3395 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3396 
    return self.recv_searchItemsInRange()
3397 
 
3398 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3399 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3400 
    args = searchItemsInRange_args()
3401 
    args.searchTerms = searchTerms
3402 
    args.offset = offset
3403 
    args.limit = limit
3404 
    args.write(self._oprot)
3405 
    self._oprot.writeMessageEnd()
3406 
    self._oprot.trans.flush()
3407 
 
3408 
  def recv_searchItemsInRange(self, ):
3409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3410 
    if mtype == TMessageType.EXCEPTION:
3411 
      x = TApplicationException()
3412 
      x.read(self._iprot)
3413 
      self._iprot.readMessageEnd()
3414 
      raise x
3415 
    result = searchItemsInRange_result()
3416 
    result.read(self._iprot)
3417 
    self._iprot.readMessageEnd()
3418 
    if result.success is not None:
3419 
      return result.success
3420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3421 
 
3422 
  def getSearchResultCount(self, searchTerms):
3423 
    """
3424 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3425 
 
3426 
    Parameters:
3427 
     - searchTerms
3428 
    """
3429 
    self.send_getSearchResultCount(searchTerms)
3430 
    return self.recv_getSearchResultCount()
3431 
 
3432 
  def send_getSearchResultCount(self, searchTerms):
3433 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3434 
    args = getSearchResultCount_args()
3435 
    args.searchTerms = searchTerms
3436 
    args.write(self._oprot)
3437 
    self._oprot.writeMessageEnd()
3438 
    self._oprot.trans.flush()
3439 
 
3440 
  def recv_getSearchResultCount(self, ):
3441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3442 
    if mtype == TMessageType.EXCEPTION:
3443 
      x = TApplicationException()
3444 
      x.read(self._iprot)
3445 
      self._iprot.readMessageEnd()
3446 
      raise x
3447 
    result = getSearchResultCount_result()
3448 
    result.read(self._iprot)
3449 
    self._iprot.readMessageEnd()
3450 
    if result.success is not None:
3451 
      return result.success
3452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3453 
 
3454 
  def getProductNotifications(self, startDateTime):
3455 
    """
3456 
    Returns a list of product notifications added after a supplied datetime
3457 
 
3458 
    Parameters:
3459 
     - startDateTime
3460 
    """
3461 
    self.send_getProductNotifications(startDateTime)
3462 
    return self.recv_getProductNotifications()
3463 
 
3464 
  def send_getProductNotifications(self, startDateTime):
3465 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3466 
    args = getProductNotifications_args()
3467 
    args.startDateTime = startDateTime
3468 
    args.write(self._oprot)
3469 
    self._oprot.writeMessageEnd()
3470 
    self._oprot.trans.flush()
3471 
 
3472 
  def recv_getProductNotifications(self, ):
3473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3474 
    if mtype == TMessageType.EXCEPTION:
3475 
      x = TApplicationException()
3476 
      x.read(self._iprot)
3477 
      self._iprot.readMessageEnd()
3478 
      raise x
3479 
    result = getProductNotifications_result()
3480 
    result.read(self._iprot)
3481 
    self._iprot.readMessageEnd()
3482 
    if result.success is not None:
3483 
      return result.success
3484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3485 
 
7897 amar.kumar 3486 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3487 
    """
3488 
    Returns a list of count of requests for product notification against each item
3489 
 
3490 
    Parameters:
3491 
     - startDateTime
7897 amar.kumar 3492 
     - categoryId
5944 mandeep.dh 3493 
    """
7897 amar.kumar 3494 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3495 
    return self.recv_getProductNotificationRequestCount()
3496 
 
7897 amar.kumar 3497 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3498 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3499 
    args = getProductNotificationRequestCount_args()
3500 
    args.startDateTime = startDateTime
7897 amar.kumar 3501 
    args.categoryId = categoryId
5944 mandeep.dh 3502 
    args.write(self._oprot)
3503 
    self._oprot.writeMessageEnd()
3504 
    self._oprot.trans.flush()
3505 
 
3506 
  def recv_getProductNotificationRequestCount(self, ):
3507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3508 
    if mtype == TMessageType.EXCEPTION:
3509 
      x = TApplicationException()
3510 
      x.read(self._iprot)
3511 
      self._iprot.readMessageEnd()
3512 
      raise x
3513 
    result = getProductNotificationRequestCount_result()
3514 
    result.read(self._iprot)
3515 
    self._iprot.readMessageEnd()
3516 
    if result.success is not None:
3517 
      return result.success
3518 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3519 
 
3520 
  def addAuthorizationLog(self, itemId, username, reason):
3521 
    """
3522 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3523 
 
3524 
    Parameters:
3525 
     - itemId
3526 
     - username
3527 
     - reason
3528 
    """
3529 
    self.send_addAuthorizationLog(itemId, username, reason)
3530 
    return self.recv_addAuthorizationLog()
3531 
 
3532 
  def send_addAuthorizationLog(self, itemId, username, reason):
3533 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3534 
    args = addAuthorizationLog_args()
3535 
    args.itemId = itemId
3536 
    args.username = username
3537 
    args.reason = reason
3538 
    args.write(self._oprot)
3539 
    self._oprot.writeMessageEnd()
3540 
    self._oprot.trans.flush()
3541 
 
3542 
  def recv_addAuthorizationLog(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 = addAuthorizationLog_result()
3550 
    result.read(self._iprot)
3551 
    self._iprot.readMessageEnd()
3552 
    if result.success is not None:
3553 
      return result.success
3554 
    if result.cex is not None:
3555 
      raise result.cex
3556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3557 
 
3558 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3559 
    """
3560 
    Parameters:
3561 
     - catalog_item_id
3562 
     - voucherType
3563 
     - voucherAmount
3564 
    """
3565 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3566 
    return self.recv_addupdateVoucherForItem()
3567 
 
3568 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3569 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3570 
    args = addupdateVoucherForItem_args()
3571 
    args.catalog_item_id = catalog_item_id
3572 
    args.voucherType = voucherType
3573 
    args.voucherAmount = voucherAmount
3574 
    args.write(self._oprot)
3575 
    self._oprot.writeMessageEnd()
3576 
    self._oprot.trans.flush()
3577 
 
3578 
  def recv_addupdateVoucherForItem(self, ):
3579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3580 
    if mtype == TMessageType.EXCEPTION:
3581 
      x = TApplicationException()
3582 
      x.read(self._iprot)
3583 
      self._iprot.readMessageEnd()
3584 
      raise x
3585 
    result = addupdateVoucherForItem_result()
3586 
    result.read(self._iprot)
3587 
    self._iprot.readMessageEnd()
3588 
    if result.success is not None:
3589 
      return result.success
3590 
    if result.cex is not None:
3591 
      raise result.cex
3592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3593 
 
3594 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3595 
    """
3596 
    Parameters:
3597 
     - catalog_item_id
3598 
     - voucherType
3599 
    """
3600 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3601 
    return self.recv_deleteVoucherForItem()
3602 
 
3603 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3604 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3605 
    args = deleteVoucherForItem_args()
3606 
    args.catalog_item_id = catalog_item_id
3607 
    args.voucherType = voucherType
3608 
    args.write(self._oprot)
3609 
    self._oprot.writeMessageEnd()
3610 
    self._oprot.trans.flush()
3611 
 
3612 
  def recv_deleteVoucherForItem(self, ):
3613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3614 
    if mtype == TMessageType.EXCEPTION:
3615 
      x = TApplicationException()
3616 
      x.read(self._iprot)
3617 
      self._iprot.readMessageEnd()
3618 
      raise x
3619 
    result = deleteVoucherForItem_result()
3620 
    result.read(self._iprot)
3621 
    self._iprot.readMessageEnd()
3622 
    if result.success is not None:
3623 
      return result.success
3624 
    if result.cex is not None:
3625 
      raise result.cex
3626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3627 
 
3628 
  def getVoucherAmount(self, itemId, voucherType):
3629 
    """
3630 
    Parameters:
3631 
     - itemId
3632 
     - voucherType
3633 
    """
3634 
    self.send_getVoucherAmount(itemId, voucherType)
3635 
    return self.recv_getVoucherAmount()
3636 
 
3637 
  def send_getVoucherAmount(self, itemId, voucherType):
3638 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3639 
    args = getVoucherAmount_args()
3640 
    args.itemId = itemId
3641 
    args.voucherType = voucherType
3642 
    args.write(self._oprot)
3643 
    self._oprot.writeMessageEnd()
3644 
    self._oprot.trans.flush()
3645 
 
3646 
  def recv_getVoucherAmount(self, ):
3647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3648 
    if mtype == TMessageType.EXCEPTION:
3649 
      x = TApplicationException()
3650 
      x.read(self._iprot)
3651 
      self._iprot.readMessageEnd()
3652 
      raise x
3653 
    result = getVoucherAmount_result()
3654 
    result.read(self._iprot)
3655 
    self._iprot.readMessageEnd()
3656 
    if result.success is not None:
3657 
      return result.success
3658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3659 
 
3660 
  def getAllItemVouchers(self, itemId):
3661 
    """
3662 
    Parameters:
3663 
     - itemId
3664 
    """
3665 
    self.send_getAllItemVouchers(itemId)
3666 
    return self.recv_getAllItemVouchers()
3667 
 
3668 
  def send_getAllItemVouchers(self, itemId):
3669 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3670 
    args = getAllItemVouchers_args()
3671 
    args.itemId = itemId
3672 
    args.write(self._oprot)
3673 
    self._oprot.writeMessageEnd()
3674 
    self._oprot.trans.flush()
3675 
 
3676 
  def recv_getAllItemVouchers(self, ):
3677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3678 
    if mtype == TMessageType.EXCEPTION:
3679 
      x = TApplicationException()
3680 
      x.read(self._iprot)
3681 
      self._iprot.readMessageEnd()
3682 
      raise x
3683 
    result = getAllItemVouchers_result()
3684 
    result.read(self._iprot)
3685 
    self._iprot.readMessageEnd()
3686 
    if result.success is not None:
3687 
      return result.success
3688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3689 
 
3690 
  def isValidCatalogItemId(self, catalog_item_id):
3691 
    """
3692 
    Parameters:
3693 
     - catalog_item_id
3694 
    """
3695 
    self.send_isValidCatalogItemId(catalog_item_id)
3696 
    return self.recv_isValidCatalogItemId()
3697 
 
3698 
  def send_isValidCatalogItemId(self, catalog_item_id):
3699 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3700 
    args = isValidCatalogItemId_args()
3701 
    args.catalog_item_id = catalog_item_id
3702 
    args.write(self._oprot)
3703 
    self._oprot.writeMessageEnd()
3704 
    self._oprot.trans.flush()
3705 
 
3706 
  def recv_isValidCatalogItemId(self, ):
3707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3708 
    if mtype == TMessageType.EXCEPTION:
3709 
      x = TApplicationException()
3710 
      x.read(self._iprot)
3711 
      self._iprot.readMessageEnd()
3712 
      raise x
3713 
    result = isValidCatalogItemId_result()
3714 
    result.read(self._iprot)
3715 
    self._iprot.readMessageEnd()
3716 
    if result.success is not None:
3717 
      return result.success
3718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3719 
 
7330 amit.gupta 3720 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3721 
    """
3722 
    Parameters:
3723 
     - itemId
7330 amit.gupta 3724 
     - stateId
6039 amit.gupta 3725 
     - price
3726 
    """
7330 amit.gupta 3727 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3728 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3729 
 
7330 amit.gupta 3730 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3731 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3732 
    args = getVatPercentageForItem_args()
3733 
    args.itemId = itemId
7330 amit.gupta 3734 
    args.stateId = stateId
6039 amit.gupta 3735 
    args.price = price
3736 
    args.write(self._oprot)
3737 
    self._oprot.writeMessageEnd()
3738 
    self._oprot.trans.flush()
3739 
 
3740 
  def recv_getVatPercentageForItem(self, ):
3741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3742 
    if mtype == TMessageType.EXCEPTION:
3743 
      x = TApplicationException()
3744 
      x.read(self._iprot)
3745 
      self._iprot.readMessageEnd()
3746 
      raise x
3747 
    result = getVatPercentageForItem_result()
3748 
    result.read(self._iprot)
3749 
    self._iprot.readMessageEnd()
3750 
    if result.success is not None:
3751 
      return result.success
7340 amit.gupta 3752 
    if result.cex is not None:
3753 
      raise result.cex
6039 amit.gupta 3754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3755 
 
3756 
  def getVatAmountForItem(self, itemId, price):
3757 
    """
3758 
    Parameters:
3759 
     - itemId
3760 
     - price
3761 
    """
3762 
    self.send_getVatAmountForItem(itemId, price)
3763 
    return self.recv_getVatAmountForItem()
3764 
 
3765 
  def send_getVatAmountForItem(self, itemId, price):
3766 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3767 
    args = getVatAmountForItem_args()
3768 
    args.itemId = itemId
3769 
    args.price = price
3770 
    args.write(self._oprot)
3771 
    self._oprot.writeMessageEnd()
3772 
    self._oprot.trans.flush()
3773 
 
3774 
  def recv_getVatAmountForItem(self, ):
3775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3776 
    if mtype == TMessageType.EXCEPTION:
3777 
      x = TApplicationException()
3778 
      x.read(self._iprot)
3779 
      self._iprot.readMessageEnd()
3780 
      raise x
3781 
    result = getVatAmountForItem_result()
3782 
    result.read(self._iprot)
3783 
    self._iprot.readMessageEnd()
3784 
    if result.success is not None:
3785 
      return result.success
3786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3787 
 
6531 vikram.rag 3788 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3789 
    """
3790 
    Parameters:
3791 
     - offset
3792 
     - limit
3793 
    """
3794 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3795 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3796 
 
6531 vikram.rag 3797 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3798 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3799 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3800 
    args.offset = offset
3801 
    args.limit = limit
3802 
    args.write(self._oprot)
3803 
    self._oprot.writeMessageEnd()
3804 
    self._oprot.trans.flush()
3805 
 
3806 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3808 
    if mtype == TMessageType.EXCEPTION:
3809 
      x = TApplicationException()
3810 
      x.read(self._iprot)
3811 
      self._iprot.readMessageEnd()
3812 
      raise x
3813 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3814 
    result.read(self._iprot)
3815 
    self._iprot.readMessageEnd()
3816 
    if result.success is not None:
3817 
      return result.success
3818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3819 
 
6821 amar.kumar 3820 
  def getAllAliveItems(self, ):
3821 
    self.send_getAllAliveItems()
3822 
    return self.recv_getAllAliveItems()
3823 
 
3824 
  def send_getAllAliveItems(self, ):
3825 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3826 
    args = getAllAliveItems_args()
3827 
    args.write(self._oprot)
3828 
    self._oprot.writeMessageEnd()
3829 
    self._oprot.trans.flush()
3830 
 
3831 
  def recv_getAllAliveItems(self, ):
3832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3833 
    if mtype == TMessageType.EXCEPTION:
3834 
      x = TApplicationException()
3835 
      x.read(self._iprot)
3836 
      self._iprot.readMessageEnd()
3837 
      raise x
3838 
    result = getAllAliveItems_result()
3839 
    result.read(self._iprot)
3840 
    self._iprot.readMessageEnd()
3841 
    if result.success is not None:
3842 
      return result.success
3843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3844 
 
6921 anupam.sin 3845 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3846 
    """
3847 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3848 
 
6805 anupam.sin 3849 
    Parameters:
3850 
     - itemId
6921 anupam.sin 3851 
     - price
6805 anupam.sin 3852 
     - insurerId
3853 
     - quantity
3854 
    """
6921 anupam.sin 3855 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3856 
    return self.recv_getInsuranceAmount()
3857 
 
6921 anupam.sin 3858 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3859 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3860 
    args = getInsuranceAmount_args()
3861 
    args.itemId = itemId
6921 anupam.sin 3862 
    args.price = price
6805 anupam.sin 3863 
    args.insurerId = insurerId
3864 
    args.quantity = quantity
3865 
    args.write(self._oprot)
3866 
    self._oprot.writeMessageEnd()
3867 
    self._oprot.trans.flush()
3868 
 
3869 
  def recv_getInsuranceAmount(self, ):
3870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3871 
    if mtype == TMessageType.EXCEPTION:
3872 
      x = TApplicationException()
3873 
      x.read(self._iprot)
3874 
      self._iprot.readMessageEnd()
3875 
      raise x
3876 
    result = getInsuranceAmount_result()
3877 
    result.read(self._iprot)
3878 
    self._iprot.readMessageEnd()
3879 
    if result.success is not None:
3880 
      return result.success
3881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3882 
 
3883 
  def getInsurer(self, insurerId):
3884 
    """
3885 
    Parameters:
3886 
     - insurerId
3887 
    """
3888 
    self.send_getInsurer(insurerId)
3889 
    return self.recv_getInsurer()
3890 
 
3891 
  def send_getInsurer(self, insurerId):
3892 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3893 
    args = getInsurer_args()
3894 
    args.insurerId = insurerId
3895 
    args.write(self._oprot)
3896 
    self._oprot.writeMessageEnd()
3897 
    self._oprot.trans.flush()
3898 
 
3899 
  def recv_getInsurer(self, ):
3900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3901 
    if mtype == TMessageType.EXCEPTION:
3902 
      x = TApplicationException()
3903 
      x.read(self._iprot)
3904 
      self._iprot.readMessageEnd()
3905 
      raise x
3906 
    result = getInsurer_result()
3907 
    result.read(self._iprot)
3908 
    self._iprot.readMessageEnd()
3909 
    if result.success is not None:
3910 
      return result.success
3911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3912 
 
6838 vikram.rag 3913 
  def getAllInsurers(self, ):
3914 
    self.send_getAllInsurers()
3915 
    return self.recv_getAllInsurers()
6805 anupam.sin 3916 
 
6838 vikram.rag 3917 
  def send_getAllInsurers(self, ):
3918 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3919 
    args = getAllInsurers_args()
3920 
    args.write(self._oprot)
3921 
    self._oprot.writeMessageEnd()
3922 
    self._oprot.trans.flush()
3923 
 
3924 
  def recv_getAllInsurers(self, ):
3925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3926 
    if mtype == TMessageType.EXCEPTION:
3927 
      x = TApplicationException()
3928 
      x.read(self._iprot)
3929 
      self._iprot.readMessageEnd()
3930 
      raise x
3931 
    result = getAllInsurers_result()
3932 
    result.read(self._iprot)
3933 
    self._iprot.readMessageEnd()
3934 
    if result.success is not None:
3935 
      return result.success
3936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3937 
 
6962 rajveer 3938 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3939 
    """
3940 
    Parameters:
3941 
     - insurerId
3942 
     - amount
3943 
    """
3944 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3945 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3946 
 
6962 rajveer 3947 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3948 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3949 
    args = updateInsuranceDeclaredAmount_args()
3950 
    args.insurerId = insurerId
3951 
    args.amount = amount
3952 
    args.write(self._oprot)
3953 
    self._oprot.writeMessageEnd()
3954 
    self._oprot.trans.flush()
3955 
 
3956 
  def recv_updateInsuranceDeclaredAmount(self, ):
3957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3958 
    if mtype == TMessageType.EXCEPTION:
3959 
      x = TApplicationException()
3960 
      x.read(self._iprot)
3961 
      self._iprot.readMessageEnd()
3962 
      raise x
3963 
    result = updateInsuranceDeclaredAmount_result()
3964 
    result.read(self._iprot)
3965 
    self._iprot.readMessageEnd()
3966 
    return
3967 
 
7190 amar.kumar 3968 
  def getFreebieForItem(self, itemId):
3969 
    """
3970 
    Parameters:
3971 
     - itemId
3972 
    """
3973 
    self.send_getFreebieForItem(itemId)
3974 
    return self.recv_getFreebieForItem()
6962 rajveer 3975 
 
7190 amar.kumar 3976 
  def send_getFreebieForItem(self, itemId):
3977 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3978 
    args = getFreebieForItem_args()
3979 
    args.itemId = itemId
3980 
    args.write(self._oprot)
3981 
    self._oprot.writeMessageEnd()
3982 
    self._oprot.trans.flush()
3983 
 
3984 
  def recv_getFreebieForItem(self, ):
3985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3986 
    if mtype == TMessageType.EXCEPTION:
3987 
      x = TApplicationException()
3988 
      x.read(self._iprot)
3989 
      self._iprot.readMessageEnd()
3990 
      raise x
3991 
    result = getFreebieForItem_result()
3992 
    result.read(self._iprot)
3993 
    self._iprot.readMessageEnd()
3994 
    if result.success is not None:
3995 
      return result.success
3996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3997 
 
3998 
  def addOrUpdateFreebieForItem(self, freebieItem):
3999 
    """
4000 
    Parameters:
4001 
     - freebieItem
4002 
    """
4003 
    self.send_addOrUpdateFreebieForItem(freebieItem)
4004 
    self.recv_addOrUpdateFreebieForItem()
4005 
 
4006 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
4007 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
4008 
    args = addOrUpdateFreebieForItem_args()
4009 
    args.freebieItem = freebieItem
4010 
    args.write(self._oprot)
4011 
    self._oprot.writeMessageEnd()
4012 
    self._oprot.trans.flush()
4013 
 
4014 
  def recv_addOrUpdateFreebieForItem(self, ):
4015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4016 
    if mtype == TMessageType.EXCEPTION:
4017 
      x = TApplicationException()
4018 
      x.read(self._iprot)
4019 
      self._iprot.readMessageEnd()
4020 
      raise x
4021 
    result = addOrUpdateFreebieForItem_result()
4022 
    result.read(self._iprot)
4023 
    self._iprot.readMessageEnd()
4024 
    return
4025 
 
7272 amit.gupta 4026 
  def addOrUpdateBrandInfo(self, brandInfo):
4027 
    """
4028 
    Parameters:
4029 
     - brandInfo
4030 
    """
4031 
    self.send_addOrUpdateBrandInfo(brandInfo)
4032 
    self.recv_addOrUpdateBrandInfo()
4033 
 
4034 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4035 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4036 
    args = addOrUpdateBrandInfo_args()
4037 
    args.brandInfo = brandInfo
4038 
    args.write(self._oprot)
4039 
    self._oprot.writeMessageEnd()
4040 
    self._oprot.trans.flush()
4041 
 
4042 
  def recv_addOrUpdateBrandInfo(self, ):
4043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4044 
    if mtype == TMessageType.EXCEPTION:
4045 
      x = TApplicationException()
4046 
      x.read(self._iprot)
4047 
      self._iprot.readMessageEnd()
4048 
      raise x
4049 
    result = addOrUpdateBrandInfo_result()
4050 
    result.read(self._iprot)
4051 
    self._iprot.readMessageEnd()
4052 
    return
4053 
 
4054 
  def getBrandInfo(self, ):
4055 
    self.send_getBrandInfo()
4056 
    return self.recv_getBrandInfo()
4057 
 
4058 
  def send_getBrandInfo(self, ):
4059 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4060 
    args = getBrandInfo_args()
4061 
    args.write(self._oprot)
4062 
    self._oprot.writeMessageEnd()
4063 
    self._oprot.trans.flush()
4064 
 
4065 
  def recv_getBrandInfo(self, ):
4066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4067 
    if mtype == TMessageType.EXCEPTION:
4068 
      x = TApplicationException()
4069 
      x.read(self._iprot)
4070 
      self._iprot.readMessageEnd()
4071 
      raise x
4072 
    result = getBrandInfo_result()
4073 
    result.read(self._iprot)
4074 
    self._iprot.readMessageEnd()
4075 
    if result.success is not None:
4076 
      return result.success
4077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4078 
 
7256 rajveer 4079 
  def getStorePricing(self, itemId):
4080 
    """
4081 
    Parameters:
4082 
     - itemId
4083 
    """
4084 
    self.send_getStorePricing(itemId)
4085 
    return self.recv_getStorePricing()
7190 amar.kumar 4086 
 
7256 rajveer 4087 
  def send_getStorePricing(self, itemId):
4088 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4089 
    args = getStorePricing_args()
4090 
    args.itemId = itemId
4091 
    args.write(self._oprot)
4092 
    self._oprot.writeMessageEnd()
4093 
    self._oprot.trans.flush()
4094 
 
4095 
  def recv_getStorePricing(self, ):
4096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4097 
    if mtype == TMessageType.EXCEPTION:
4098 
      x = TApplicationException()
4099 
      x.read(self._iprot)
4100 
      self._iprot.readMessageEnd()
4101 
      raise x
4102 
    result = getStorePricing_result()
4103 
    result.read(self._iprot)
4104 
    self._iprot.readMessageEnd()
4105 
    if result.success is not None:
4106 
      return result.success
4107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4108 
 
7306 rajveer 4109 
  def getStorePricings(self, itemIds):
4110 
    """
4111 
    Parameters:
4112 
     - itemIds
4113 
    """
4114 
    self.send_getStorePricings(itemIds)
4115 
    return self.recv_getStorePricings()
4116 
 
4117 
  def send_getStorePricings(self, itemIds):
4118 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4119 
    args = getStorePricings_args()
4120 
    args.itemIds = itemIds
4121 
    args.write(self._oprot)
4122 
    self._oprot.writeMessageEnd()
4123 
    self._oprot.trans.flush()
4124 
 
4125 
  def recv_getStorePricings(self, ):
4126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4127 
    if mtype == TMessageType.EXCEPTION:
4128 
      x = TApplicationException()
4129 
      x.read(self._iprot)
4130 
      self._iprot.readMessageEnd()
4131 
      raise x
4132 
    result = getStorePricings_result()
4133 
    result.read(self._iprot)
4134 
    self._iprot.readMessageEnd()
4135 
    if result.success is not None:
4136 
      return result.success
4137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4138 
 
7382 rajveer 4139 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4140 
    """
4141 
    Parameters:
4142 
     - sp
7382 rajveer 4143 
     - allColors
7265 rajveer 4144 
    """
7382 rajveer 4145 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4146 
    self.recv_updateStorePricing()
7256 rajveer 4147 
 
7382 rajveer 4148 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4149 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4150 
    args = updateStorePricing_args()
4151 
    args.sp = sp
7382 rajveer 4152 
    args.allColors = allColors
7265 rajveer 4153 
    args.write(self._oprot)
4154 
    self._oprot.writeMessageEnd()
4155 
    self._oprot.trans.flush()
4156 
 
4157 
  def recv_updateStorePricing(self, ):
4158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4159 
    if mtype == TMessageType.EXCEPTION:
4160 
      x = TApplicationException()
4161 
      x.read(self._iprot)
4162 
      self._iprot.readMessageEnd()
4163 
      raise x
4164 
    result = updateStorePricing_result()
4165 
    result.read(self._iprot)
4166 
    self._iprot.readMessageEnd()
4167 
    return
4168 
 
7281 kshitij.so 4169 
  def getAllAmazonListedItems(self, ):
4170 
    self.send_getAllAmazonListedItems()
4171 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4172 
 
7281 kshitij.so 4173 
  def send_getAllAmazonListedItems(self, ):
4174 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4175 
    args = getAllAmazonListedItems_args()
4176 
    args.write(self._oprot)
4177 
    self._oprot.writeMessageEnd()
4178 
    self._oprot.trans.flush()
4179 
 
4180 
  def recv_getAllAmazonListedItems(self, ):
4181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4182 
    if mtype == TMessageType.EXCEPTION:
4183 
      x = TApplicationException()
4184 
      x.read(self._iprot)
4185 
      self._iprot.readMessageEnd()
4186 
      raise x
4187 
    result = getAllAmazonListedItems_result()
4188 
    result.read(self._iprot)
4189 
    self._iprot.readMessageEnd()
4190 
    if result.success is not None:
4191 
      return result.success
4192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4193 
 
8619 kshitij.so 4194 
  def searchAmazonItems(self, searchTerm, offset, limit):
4195 
    """
4196 
    Parameters:
4197 
     - searchTerm
4198 
     - offset
4199 
     - limit
4200 
    """
4201 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4202 
    return self.recv_searchAmazonItems()
4203 
 
4204 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4205 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4206 
    args = searchAmazonItems_args()
4207 
    args.searchTerm = searchTerm
4208 
    args.offset = offset
4209 
    args.limit = limit
4210 
    args.write(self._oprot)
4211 
    self._oprot.writeMessageEnd()
4212 
    self._oprot.trans.flush()
4213 
 
4214 
  def recv_searchAmazonItems(self, ):
4215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4216 
    if mtype == TMessageType.EXCEPTION:
4217 
      x = TApplicationException()
4218 
      x.read(self._iprot)
4219 
      self._iprot.readMessageEnd()
4220 
      raise x
4221 
    result = searchAmazonItems_result()
4222 
    result.read(self._iprot)
4223 
    self._iprot.readMessageEnd()
4224 
    if result.success is not None:
4225 
      return result.success
4226 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4227 
 
4228 
  def getAmazonSearchResultCount(self, searchTerm):
4229 
    """
4230 
    Parameters:
4231 
     - searchTerm
4232 
    """
4233 
    self.send_getAmazonSearchResultCount(searchTerm)
4234 
    return self.recv_getAmazonSearchResultCount()
4235 
 
4236 
  def send_getAmazonSearchResultCount(self, searchTerm):
4237 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4238 
    args = getAmazonSearchResultCount_args()
4239 
    args.searchTerm = searchTerm
4240 
    args.write(self._oprot)
4241 
    self._oprot.writeMessageEnd()
4242 
    self._oprot.trans.flush()
4243 
 
4244 
  def recv_getAmazonSearchResultCount(self, ):
4245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4246 
    if mtype == TMessageType.EXCEPTION:
4247 
      x = TApplicationException()
4248 
      x.read(self._iprot)
4249 
      self._iprot.readMessageEnd()
4250 
      raise x
4251 
    result = getAmazonSearchResultCount_result()
4252 
    result.read(self._iprot)
4253 
    self._iprot.readMessageEnd()
4254 
    if result.success is not None:
4255 
      return result.success
4256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4257 
 
4258 
  def getCountForAmazonlistedItems(self, ):
4259 
    self.send_getCountForAmazonlistedItems()
4260 
    return self.recv_getCountForAmazonlistedItems()
4261 
 
4262 
  def send_getCountForAmazonlistedItems(self, ):
4263 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4264 
    args = getCountForAmazonlistedItems_args()
4265 
    args.write(self._oprot)
4266 
    self._oprot.writeMessageEnd()
4267 
    self._oprot.trans.flush()
4268 
 
4269 
  def recv_getCountForAmazonlistedItems(self, ):
4270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4271 
    if mtype == TMessageType.EXCEPTION:
4272 
      x = TApplicationException()
4273 
      x.read(self._iprot)
4274 
      self._iprot.readMessageEnd()
4275 
      raise x
4276 
    result = getCountForAmazonlistedItems_result()
4277 
    result.read(self._iprot)
4278 
    self._iprot.readMessageEnd()
4279 
    if result.success is not None:
4280 
      return result.success
4281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4282 
 
7281 kshitij.so 4283 
  def getAmazonItemDetails(self, itemId):
4284 
    """
4285 
    Parameters:
4286 
     - itemId
4287 
    """
4288 
    self.send_getAmazonItemDetails(itemId)
4289 
    return self.recv_getAmazonItemDetails()
4290 
 
4291 
  def send_getAmazonItemDetails(self, itemId):
4292 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4293 
    args = getAmazonItemDetails_args()
4294 
    args.itemId = itemId
4295 
    args.write(self._oprot)
4296 
    self._oprot.writeMessageEnd()
4297 
    self._oprot.trans.flush()
4298 
 
4299 
  def recv_getAmazonItemDetails(self, ):
4300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4301 
    if mtype == TMessageType.EXCEPTION:
4302 
      x = TApplicationException()
4303 
      x.read(self._iprot)
4304 
      self._iprot.readMessageEnd()
4305 
      raise x
4306 
    result = getAmazonItemDetails_result()
4307 
    result.read(self._iprot)
4308 
    self._iprot.readMessageEnd()
4309 
    if result.success is not None:
4310 
      return result.success
4311 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4312 
 
8168 kshitij.so 4313 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4314 
    """
4315 
    Parameters:
8168 kshitij.so 4316 
     - amazonlisted
7281 kshitij.so 4317 
    """
8168 kshitij.so 4318 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4319 
    self.recv_updateAmazonItemDetails()
4320 
 
8168 kshitij.so 4321 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4322 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4323 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4324 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4325 
    args.write(self._oprot)
4326 
    self._oprot.writeMessageEnd()
4327 
    self._oprot.trans.flush()
4328 
 
4329 
  def recv_updateAmazonItemDetails(self, ):
4330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4331 
    if mtype == TMessageType.EXCEPTION:
4332 
      x = TApplicationException()
4333 
      x.read(self._iprot)
4334 
      self._iprot.readMessageEnd()
4335 
      raise x
4336 
    result = updateAmazonItemDetails_result()
4337 
    result.read(self._iprot)
4338 
    self._iprot.readMessageEnd()
4339 
    return
4340 
 
4341 
  def addAmazonItem(self, amazonlisted):
4342 
    """
4343 
    Parameters:
4344 
     - amazonlisted
4345 
    """
4346 
    self.send_addAmazonItem(amazonlisted)
4347 
    self.recv_addAmazonItem()
4348 
 
4349 
  def send_addAmazonItem(self, amazonlisted):
4350 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4351 
    args = addAmazonItem_args()
4352 
    args.amazonlisted = amazonlisted
4353 
    args.write(self._oprot)
4354 
    self._oprot.writeMessageEnd()
4355 
    self._oprot.trans.flush()
4356 
 
4357 
  def recv_addAmazonItem(self, ):
4358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4359 
    if mtype == TMessageType.EXCEPTION:
4360 
      x = TApplicationException()
4361 
      x.read(self._iprot)
4362 
      self._iprot.readMessageEnd()
4363 
      raise x
4364 
    result = addAmazonItem_result()
4365 
    result.read(self._iprot)
4366 
    self._iprot.readMessageEnd()
4367 
    return
4368 
 
7291 vikram.rag 4369 
  def getAsinItems(self, ):
4370 
    self.send_getAsinItems()
4371 
    return self.recv_getAsinItems()
7281 kshitij.so 4372 
 
7291 vikram.rag 4373 
  def send_getAsinItems(self, ):
4374 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4375 
    args = getAsinItems_args()
4376 
    args.write(self._oprot)
4377 
    self._oprot.writeMessageEnd()
4378 
    self._oprot.trans.flush()
4379 
 
4380 
  def recv_getAsinItems(self, ):
4381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4382 
    if mtype == TMessageType.EXCEPTION:
4383 
      x = TApplicationException()
4384 
      x.read(self._iprot)
4385 
      self._iprot.readMessageEnd()
4386 
      raise x
4387 
    result = getAsinItems_result()
4388 
    result.read(self._iprot)
4389 
    self._iprot.readMessageEnd()
4390 
    if result.success is not None:
4391 
      return result.success
4392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4393 
 
4394 
  def getAllFbaListedItems(self, ):
4395 
    self.send_getAllFbaListedItems()
4396 
    return self.recv_getAllFbaListedItems()
4397 
 
4398 
  def send_getAllFbaListedItems(self, ):
4399 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4400 
    args = getAllFbaListedItems_args()
4401 
    args.write(self._oprot)
4402 
    self._oprot.writeMessageEnd()
4403 
    self._oprot.trans.flush()
4404 
 
4405 
  def recv_getAllFbaListedItems(self, ):
4406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4407 
    if mtype == TMessageType.EXCEPTION:
4408 
      x = TApplicationException()
4409 
      x.read(self._iprot)
4410 
      self._iprot.readMessageEnd()
4411 
      raise x
4412 
    result = getAllFbaListedItems_result()
4413 
    result.read(self._iprot)
4414 
    self._iprot.readMessageEnd()
4415 
    if result.success is not None:
4416 
      return result.success
4417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4418 
 
4419 
  def getAllNonFbaListedItems(self, ):
4420 
    self.send_getAllNonFbaListedItems()
4421 
    return self.recv_getAllNonFbaListedItems()
4422 
 
4423 
  def send_getAllNonFbaListedItems(self, ):
4424 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4425 
    args = getAllNonFbaListedItems_args()
4426 
    args.write(self._oprot)
4427 
    self._oprot.writeMessageEnd()
4428 
    self._oprot.trans.flush()
4429 
 
4430 
  def recv_getAllNonFbaListedItems(self, ):
4431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4432 
    if mtype == TMessageType.EXCEPTION:
4433 
      x = TApplicationException()
4434 
      x.read(self._iprot)
4435 
      self._iprot.readMessageEnd()
4436 
      raise x
4437 
    result = getAllNonFbaListedItems_result()
4438 
    result.read(self._iprot)
4439 
    self._iprot.readMessageEnd()
4440 
    if result.success is not None:
4441 
      return result.success
4442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4443 
 
7460 kshitij.so 4444 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4445 
    """
4446 
    Parameters:
4447 
     - itemId
4448 
     - holdInventory
4449 
     - defaultInventory
4450 
    """
4451 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4452 
    return self.recv_updateItemInventory()
7291 vikram.rag 4453 
 
7460 kshitij.so 4454 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4455 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4456 
    args = updateItemInventory_args()
4457 
    args.itemId = itemId
4458 
    args.holdInventory = holdInventory
4459 
    args.defaultInventory = defaultInventory
4460 
    args.write(self._oprot)
4461 
    self._oprot.writeMessageEnd()
4462 
    self._oprot.trans.flush()
4463 
 
4464 
  def recv_updateItemInventory(self, ):
4465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4466 
    if mtype == TMessageType.EXCEPTION:
4467 
      x = TApplicationException()
4468 
      x.read(self._iprot)
4469 
      self._iprot.readMessageEnd()
4470 
      raise x
4471 
    result = updateItemInventory_result()
4472 
    result.read(self._iprot)
4473 
    self._iprot.readMessageEnd()
4474 
    if result.success is not None:
4475 
      return result.success
4476 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4477 
 
7770 kshitij.so 4478 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4479 
    """
4480 
    Parameters:
4481 
     - type
4482 
     - sku
4483 
     - timestamp
4484 
    """
4485 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4486 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4487 
 
7770 kshitij.so 4488 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4489 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4490 
    args = updateTimestampForAmazonFeeds_args()
4491 
    args.type = type
4492 
    args.sku = sku
4493 
    args.timestamp = timestamp
4494 
    args.write(self._oprot)
4495 
    self._oprot.writeMessageEnd()
4496 
    self._oprot.trans.flush()
4497 
 
4498 
  def recv_updateTimestampForAmazonFeeds(self, ):
4499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4500 
    if mtype == TMessageType.EXCEPTION:
4501 
      x = TApplicationException()
4502 
      x.read(self._iprot)
4503 
      self._iprot.readMessageEnd()
4504 
      raise x
4505 
    result = updateTimestampForAmazonFeeds_result()
4506 
    result.read(self._iprot)
4507 
    self._iprot.readMessageEnd()
4508 
    if result.success is not None:
4509 
      return result.success
4510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4511 
 
7897 amar.kumar 4512 
  def getAllParentCategories(self, ):
4513 
    self.send_getAllParentCategories()
4514 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4515 
 
7897 amar.kumar 4516 
  def send_getAllParentCategories(self, ):
4517 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4518 
    args = getAllParentCategories_args()
4519 
    args.write(self._oprot)
4520 
    self._oprot.writeMessageEnd()
4521 
    self._oprot.trans.flush()
4522 
 
4523 
  def recv_getAllParentCategories(self, ):
4524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4525 
    if mtype == TMessageType.EXCEPTION:
4526 
      x = TApplicationException()
4527 
      x.read(self._iprot)
4528 
      self._iprot.readMessageEnd()
4529 
      raise x
4530 
    result = getAllParentCategories_result()
4531 
    result.read(self._iprot)
4532 
    self._iprot.readMessageEnd()
4533 
    if result.success is not None:
4534 
      return result.success
4535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4536 
 
7977 kshitij.so 4537 
  def addPageViewEvent(self, pageViewEvents):
4538 
    """
4539 
    Parameters:
4540 
     - pageViewEvents
4541 
    """
4542 
    self.send_addPageViewEvent(pageViewEvents)
4543 
    self.recv_addPageViewEvent()
7897 amar.kumar 4544 
 
7977 kshitij.so 4545 
  def send_addPageViewEvent(self, pageViewEvents):
4546 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4547 
    args = addPageViewEvent_args()
4548 
    args.pageViewEvents = pageViewEvents
4549 
    args.write(self._oprot)
4550 
    self._oprot.writeMessageEnd()
4551 
    self._oprot.trans.flush()
4552 
 
4553 
  def recv_addPageViewEvent(self, ):
4554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4555 
    if mtype == TMessageType.EXCEPTION:
4556 
      x = TApplicationException()
4557 
      x.read(self._iprot)
4558 
      self._iprot.readMessageEnd()
4559 
      raise x
4560 
    result = addPageViewEvent_result()
4561 
    result.read(self._iprot)
4562 
    self._iprot.readMessageEnd()
4563 
    return
4564 
 
4565 
  def addCartEvent(self, cartEvents):
4566 
    """
4567 
    Parameters:
4568 
     - cartEvents
4569 
    """
4570 
    self.send_addCartEvent(cartEvents)
4571 
    self.recv_addCartEvent()
4572 
 
4573 
  def send_addCartEvent(self, cartEvents):
4574 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4575 
    args = addCartEvent_args()
4576 
    args.cartEvents = cartEvents
4577 
    args.write(self._oprot)
4578 
    self._oprot.writeMessageEnd()
4579 
    self._oprot.trans.flush()
4580 
 
4581 
  def recv_addCartEvent(self, ):
4582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4583 
    if mtype == TMessageType.EXCEPTION:
4584 
      x = TApplicationException()
4585 
      x.read(self._iprot)
4586 
      self._iprot.readMessageEnd()
4587 
      raise x
4588 
    result = addCartEvent_result()
4589 
    result.read(self._iprot)
4590 
    self._iprot.readMessageEnd()
4591 
    return
4592 
 
8182 amar.kumar 4593 
  def addEbayItem(self, ebayItem):
4594 
    """
4595 
    Parameters:
4596 
     - ebayItem
4597 
    """
4598 
    self.send_addEbayItem(ebayItem)
4599 
    self.recv_addEbayItem()
4600 
 
4601 
  def send_addEbayItem(self, ebayItem):
4602 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4603 
    args = addEbayItem_args()
4604 
    args.ebayItem = ebayItem
4605 
    args.write(self._oprot)
4606 
    self._oprot.writeMessageEnd()
4607 
    self._oprot.trans.flush()
4608 
 
4609 
  def recv_addEbayItem(self, ):
4610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4611 
    if mtype == TMessageType.EXCEPTION:
4612 
      x = TApplicationException()
4613 
      x.read(self._iprot)
4614 
      self._iprot.readMessageEnd()
4615 
      raise x
4616 
    result = addEbayItem_result()
4617 
    result.read(self._iprot)
4618 
    self._iprot.readMessageEnd()
4619 
    return
4620 
 
4621 
  def getEbayItem(self, listingId):
4622 
    """
4623 
    Parameters:
4624 
     - listingId
4625 
    """
4626 
    self.send_getEbayItem(listingId)
4627 
    return self.recv_getEbayItem()
4628 
 
4629 
  def send_getEbayItem(self, listingId):
4630 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4631 
    args = getEbayItem_args()
4632 
    args.listingId = listingId
4633 
    args.write(self._oprot)
4634 
    self._oprot.writeMessageEnd()
4635 
    self._oprot.trans.flush()
4636 
 
4637 
  def recv_getEbayItem(self, ):
4638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4639 
    if mtype == TMessageType.EXCEPTION:
4640 
      x = TApplicationException()
4641 
      x.read(self._iprot)
4642 
      self._iprot.readMessageEnd()
4643 
      raise x
4644 
    result = getEbayItem_result()
4645 
    result.read(self._iprot)
4646 
    self._iprot.readMessageEnd()
4647 
    if result.success is not None:
4648 
      return result.success
4649 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4650 
 
4651 
  def updateEbayItem(self, ebayItem):
4652 
    """
4653 
    Parameters:
4654 
     - ebayItem
4655 
    """
4656 
    self.send_updateEbayItem(ebayItem)
4657 
    self.recv_updateEbayItem()
4658 
 
4659 
  def send_updateEbayItem(self, ebayItem):
4660 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4661 
    args = updateEbayItem_args()
4662 
    args.ebayItem = ebayItem
4663 
    args.write(self._oprot)
4664 
    self._oprot.writeMessageEnd()
4665 
    self._oprot.trans.flush()
4666 
 
4667 
  def recv_updateEbayItem(self, ):
4668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4669 
    if mtype == TMessageType.EXCEPTION:
4670 
      x = TApplicationException()
4671 
      x.read(self._iprot)
4672 
      self._iprot.readMessageEnd()
4673 
      raise x
4674 
    result = updateEbayItem_result()
4675 
    result.read(self._iprot)
4676 
    self._iprot.readMessageEnd()
4677 
    return
4678 
 
8139 kshitij.so 4679 
  def getAmazonListedItems(self, offset, limit):
4680 
    """
4681 
    Parameters:
4682 
     - offset
4683 
     - limit
4684 
    """
4685 
    self.send_getAmazonListedItems(offset, limit)
4686 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4687 
 
8139 kshitij.so 4688 
  def send_getAmazonListedItems(self, offset, limit):
4689 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4690 
    args = getAmazonListedItems_args()
4691 
    args.offset = offset
4692 
    args.limit = limit
4693 
    args.write(self._oprot)
4694 
    self._oprot.writeMessageEnd()
4695 
    self._oprot.trans.flush()
4696 
 
4697 
  def recv_getAmazonListedItems(self, ):
4698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4699 
    if mtype == TMessageType.EXCEPTION:
4700 
      x = TApplicationException()
4701 
      x.read(self._iprot)
4702 
      self._iprot.readMessageEnd()
4703 
      raise x
4704 
    result = getAmazonListedItems_result()
4705 
    result.read(self._iprot)
4706 
    self._iprot.readMessageEnd()
4707 
    if result.success is not None:
4708 
      return result.success
4709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4710 
 
8168 kshitij.so 4711 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4712 
    """
4713 
    Parameters:
4714 
     - amazonlisted
4715 
    """
4716 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4717 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4718 
 
8168 kshitij.so 4719 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4720 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4721 
    args = updateAmazonAttributesInBulk_args()
4722 
    args.amazonlisted = amazonlisted
4723 
    args.write(self._oprot)
4724 
    self._oprot.writeMessageEnd()
4725 
    self._oprot.trans.flush()
4726 
 
4727 
  def recv_updateAmazonAttributesInBulk(self, ):
4728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4729 
    if mtype == TMessageType.EXCEPTION:
4730 
      x = TApplicationException()
4731 
      x.read(self._iprot)
4732 
      self._iprot.readMessageEnd()
4733 
      raise x
4734 
    result = updateAmazonAttributesInBulk_result()
4735 
    result.read(self._iprot)
4736 
    self._iprot.readMessageEnd()
4737 
    if result.success is not None:
4738 
      return result.success
4739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4740 
 
8379 vikram.rag 4741 
  def getAllItemstoListOnFba(self, ):
4742 
    self.send_getAllItemstoListOnFba()
4743 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4744 
 
8379 vikram.rag 4745 
  def send_getAllItemstoListOnFba(self, ):
4746 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4747 
    args = getAllItemstoListOnFba_args()
4748 
    args.write(self._oprot)
4749 
    self._oprot.writeMessageEnd()
4750 
    self._oprot.trans.flush()
4751 
 
4752 
  def recv_getAllItemstoListOnFba(self, ):
4753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4754 
    if mtype == TMessageType.EXCEPTION:
4755 
      x = TApplicationException()
4756 
      x.read(self._iprot)
4757 
      self._iprot.readMessageEnd()
4758 
      raise x
4759 
    result = getAllItemstoListOnFba_result()
4760 
    result.read(self._iprot)
4761 
    self._iprot.readMessageEnd()
4762 
    if result.success is not None:
4763 
      return result.success
4764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4765 
 
4766 
  def getAllItemstoListOnNonFba(self, ):
4767 
    self.send_getAllItemstoListOnNonFba()
4768 
    return self.recv_getAllItemstoListOnNonFba()
4769 
 
4770 
  def send_getAllItemstoListOnNonFba(self, ):
4771 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4772 
    args = getAllItemstoListOnNonFba_args()
4773 
    args.write(self._oprot)
4774 
    self._oprot.writeMessageEnd()
4775 
    self._oprot.trans.flush()
4776 
 
4777 
  def recv_getAllItemstoListOnNonFba(self, ):
4778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4779 
    if mtype == TMessageType.EXCEPTION:
4780 
      x = TApplicationException()
4781 
      x.read(self._iprot)
4782 
      self._iprot.readMessageEnd()
4783 
      raise x
4784 
    result = getAllItemstoListOnNonFba_result()
4785 
    result.read(self._iprot)
4786 
    self._iprot.readMessageEnd()
4787 
    if result.success is not None:
4788 
      return result.success
4789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4790 
 
8619 kshitij.so 4791 
  def updateAsin(self, item):
4792 
    """
4793 
    Parameters:
4794 
     - item
4795 
    """
4796 
    self.send_updateAsin(item)
4797 
    self.recv_updateAsin()
8616 vikram.rag 4798 
 
8619 kshitij.so 4799 
  def send_updateAsin(self, item):
4800 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4801 
    args = updateAsin_args()
4802 
    args.item = item
4803 
    args.write(self._oprot)
4804 
    self._oprot.writeMessageEnd()
4805 
    self._oprot.trans.flush()
4806 
 
4807 
  def recv_updateAsin(self, ):
4808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4809 
    if mtype == TMessageType.EXCEPTION:
4810 
      x = TApplicationException()
4811 
      x.read(self._iprot)
4812 
      self._iprot.readMessageEnd()
4813 
      raise x
4814 
    result = updateAsin_result()
4815 
    result.read(self._iprot)
4816 
    self._iprot.readMessageEnd()
4817 
    return
4818 
 
8739 vikram.rag 4819 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4820 
    """
4821 
    Parameters:
4822 
     - snapdealitem
4823 
    """
4824 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4825 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4826 
 
8739 vikram.rag 4827 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4828 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4829 
    args = addOrUpdateSnapdealItem_args()
4830 
    args.snapdealitem = snapdealitem
4831 
    args.write(self._oprot)
4832 
    self._oprot.writeMessageEnd()
4833 
    self._oprot.trans.flush()
4834 
 
4835 
  def recv_addOrUpdateSnapdealItem(self, ):
4836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4837 
    if mtype == TMessageType.EXCEPTION:
4838 
      x = TApplicationException()
4839 
      x.read(self._iprot)
4840 
      self._iprot.readMessageEnd()
4841 
      raise x
4842 
    result = addOrUpdateSnapdealItem_result()
4843 
    result.read(self._iprot)
4844 
    self._iprot.readMessageEnd()
4845 
    if result.success is not None:
4846 
      return result.success
4847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4848 
 
4849 
  def getSnapdealItem(self, item_id):
4850 
    """
4851 
    Parameters:
4852 
     - item_id
4853 
    """
4854 
    self.send_getSnapdealItem(item_id)
4855 
    return self.recv_getSnapdealItem()
4856 
 
4857 
  def send_getSnapdealItem(self, item_id):
4858 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4859 
    args = getSnapdealItem_args()
4860 
    args.item_id = item_id
4861 
    args.write(self._oprot)
4862 
    self._oprot.writeMessageEnd()
4863 
    self._oprot.trans.flush()
4864 
 
4865 
  def recv_getSnapdealItem(self, ):
4866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4867 
    if mtype == TMessageType.EXCEPTION:
4868 
      x = TApplicationException()
4869 
      x.read(self._iprot)
4870 
      self._iprot.readMessageEnd()
4871 
      raise x
4872 
    result = getSnapdealItem_result()
4873 
    result.read(self._iprot)
4874 
    self._iprot.readMessageEnd()
4875 
    if result.success is not None:
4876 
      return result.success
4877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4878 
 
9242 kshitij.so 4879 
  def getSnapdealItemDetails(self, item_id):
4880 
    """
4881 
    Parameters:
4882 
     - item_id
4883 
    """
4884 
    self.send_getSnapdealItemDetails(item_id)
4885 
    return self.recv_getSnapdealItemDetails()
4886 
 
4887 
  def send_getSnapdealItemDetails(self, item_id):
4888 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
4889 
    args = getSnapdealItemDetails_args()
4890 
    args.item_id = item_id
4891 
    args.write(self._oprot)
4892 
    self._oprot.writeMessageEnd()
4893 
    self._oprot.trans.flush()
4894 
 
4895 
  def recv_getSnapdealItemDetails(self, ):
4896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4897 
    if mtype == TMessageType.EXCEPTION:
4898 
      x = TApplicationException()
4899 
      x.read(self._iprot)
4900 
      self._iprot.readMessageEnd()
4901 
      raise x
4902 
    result = getSnapdealItemDetails_result()
4903 
    result.read(self._iprot)
4904 
    self._iprot.readMessageEnd()
4905 
    if result.success is not None:
4906 
      return result.success
4907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
4908 
 
8739 vikram.rag 4909 
  def getAllSnapdealItems(self, ):
4910 
    self.send_getAllSnapdealItems()
4911 
    return self.recv_getAllSnapdealItems()
4912 
 
4913 
  def send_getAllSnapdealItems(self, ):
4914 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4915 
    args = getAllSnapdealItems_args()
4916 
    args.write(self._oprot)
4917 
    self._oprot.writeMessageEnd()
4918 
    self._oprot.trans.flush()
4919 
 
4920 
  def recv_getAllSnapdealItems(self, ):
4921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4922 
    if mtype == TMessageType.EXCEPTION:
4923 
      x = TApplicationException()
4924 
      x.read(self._iprot)
4925 
      self._iprot.readMessageEnd()
4926 
      raise x
4927 
    result = getAllSnapdealItems_result()
4928 
    result.read(self._iprot)
4929 
    self._iprot.readMessageEnd()
4930 
    if result.success is not None:
4931 
      return result.success
4932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4933 
 
9242 kshitij.so 4934 
  def getSnapdealItems(self, offset, limit):
4935 
    """
4936 
    Parameters:
4937 
     - offset
4938 
     - limit
4939 
    """
4940 
    self.send_getSnapdealItems(offset, limit)
4941 
    return self.recv_getSnapdealItems()
8739 vikram.rag 4942 
 
9242 kshitij.so 4943 
  def send_getSnapdealItems(self, offset, limit):
4944 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
4945 
    args = getSnapdealItems_args()
4946 
    args.offset = offset
4947 
    args.limit = limit
4948 
    args.write(self._oprot)
4949 
    self._oprot.writeMessageEnd()
4950 
    self._oprot.trans.flush()
4951 
 
4952 
  def recv_getSnapdealItems(self, ):
4953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4954 
    if mtype == TMessageType.EXCEPTION:
4955 
      x = TApplicationException()
4956 
      x.read(self._iprot)
4957 
      self._iprot.readMessageEnd()
4958 
      raise x
4959 
    result = getSnapdealItems_result()
4960 
    result.read(self._iprot)
4961 
    self._iprot.readMessageEnd()
4962 
    if result.success is not None:
4963 
      return result.success
4964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
4965 
 
4966 
  def searchSnapdealItems(self, searchTerm, offset, limit):
4967 
    """
4968 
    Parameters:
4969 
     - searchTerm
4970 
     - offset
4971 
     - limit
4972 
    """
4973 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
4974 
    return self.recv_searchSnapdealItems()
4975 
 
4976 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
4977 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
4978 
    args = searchSnapdealItems_args()
4979 
    args.searchTerm = searchTerm
4980 
    args.offset = offset
4981 
    args.limit = limit
4982 
    args.write(self._oprot)
4983 
    self._oprot.writeMessageEnd()
4984 
    self._oprot.trans.flush()
4985 
 
4986 
  def recv_searchSnapdealItems(self, ):
4987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4988 
    if mtype == TMessageType.EXCEPTION:
4989 
      x = TApplicationException()
4990 
      x.read(self._iprot)
4991 
      self._iprot.readMessageEnd()
4992 
      raise x
4993 
    result = searchSnapdealItems_result()
4994 
    result.read(self._iprot)
4995 
    self._iprot.readMessageEnd()
4996 
    if result.success is not None:
4997 
      return result.success
4998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
4999 
 
5000 
  def getCountForSnapdealItems(self, ):
5001 
    self.send_getCountForSnapdealItems()
5002 
    return self.recv_getCountForSnapdealItems()
5003 
 
5004 
  def send_getCountForSnapdealItems(self, ):
5005 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
5006 
    args = getCountForSnapdealItems_args()
5007 
    args.write(self._oprot)
5008 
    self._oprot.writeMessageEnd()
5009 
    self._oprot.trans.flush()
5010 
 
5011 
  def recv_getCountForSnapdealItems(self, ):
5012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5013 
    if mtype == TMessageType.EXCEPTION:
5014 
      x = TApplicationException()
5015 
      x.read(self._iprot)
5016 
      self._iprot.readMessageEnd()
5017 
      raise x
5018 
    result = getCountForSnapdealItems_result()
5019 
    result.read(self._iprot)
5020 
    self._iprot.readMessageEnd()
5021 
    if result.success is not None:
5022 
      return result.success
5023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5024 
 
5025 
  def getSnapdealSearchResultCount(self, searchTerm):
5026 
    """
5027 
    Parameters:
5028 
     - searchTerm
5029 
    """
5030 
    self.send_getSnapdealSearchResultCount(searchTerm)
5031 
    return self.recv_getSnapdealSearchResultCount()
5032 
 
5033 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5034 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5035 
    args = getSnapdealSearchResultCount_args()
5036 
    args.searchTerm = searchTerm
5037 
    args.write(self._oprot)
5038 
    self._oprot.writeMessageEnd()
5039 
    self._oprot.trans.flush()
5040 
 
5041 
  def recv_getSnapdealSearchResultCount(self, ):
5042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5043 
    if mtype == TMessageType.EXCEPTION:
5044 
      x = TApplicationException()
5045 
      x.read(self._iprot)
5046 
      self._iprot.readMessageEnd()
5047 
      raise x
5048 
    result = getSnapdealSearchResultCount_result()
5049 
    result.read(self._iprot)
5050 
    self._iprot.readMessageEnd()
5051 
    if result.success is not None:
5052 
      return result.success
5053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5054 
 
9299 kshitij.so 5055 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5056 
    """
5057 
    Parameters:
5058 
     - itemId
5059 
     - insurerType
5060 
    """
5061 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5062 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5063 
 
9299 kshitij.so 5064 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5065 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5066 
    args = getPrefferedInsurerForItem_args()
5067 
    args.itemId = itemId
5068 
    args.insurerType = insurerType
5069 
    args.write(self._oprot)
5070 
    self._oprot.writeMessageEnd()
5071 
    self._oprot.trans.flush()
5072 
 
5073 
  def recv_getPrefferedInsurerForItem(self, ):
5074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5075 
    if mtype == TMessageType.EXCEPTION:
5076 
      x = TApplicationException()
5077 
      x.read(self._iprot)
5078 
      self._iprot.readMessageEnd()
5079 
      raise x
5080 
    result = getPrefferedInsurerForItem_result()
5081 
    result.read(self._iprot)
5082 
    self._iprot.readMessageEnd()
5083 
    if result.success is not None:
5084 
      return result.success
5085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5086 
 
9456 vikram.rag 5087 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5088 
    """
5089 
    Parameters:
5090 
     - skuAtSnapdeal
5091 
    """
5092 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5093 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5094 
 
9456 vikram.rag 5095 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5096 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5097 
    args = getSnapdealItembySkuAtSnapdeal_args()
5098 
    args.skuAtSnapdeal = skuAtSnapdeal
5099 
    args.write(self._oprot)
5100 
    self._oprot.writeMessageEnd()
5101 
    self._oprot.trans.flush()
5102 
 
5103 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5105 
    if mtype == TMessageType.EXCEPTION:
5106 
      x = TApplicationException()
5107 
      x.read(self._iprot)
5108 
      self._iprot.readMessageEnd()
5109 
      raise x
5110 
    result = getSnapdealItembySkuAtSnapdeal_result()
5111 
    result.read(self._iprot)
5112 
    self._iprot.readMessageEnd()
5113 
    if result.success is not None:
5114 
      return result.success
5115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5116 
 
9621 manish.sha 5117 
  def getProductFeedSubmit(self, catalogItemId):
5118 
    """
5119 
    Parameters:
5120 
     - catalogItemId
5121 
    """
5122 
    self.send_getProductFeedSubmit(catalogItemId)
5123 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5124 
 
9621 manish.sha 5125 
  def send_getProductFeedSubmit(self, catalogItemId):
5126 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5127 
    args = getProductFeedSubmit_args()
5128 
    args.catalogItemId = catalogItemId
5129 
    args.write(self._oprot)
5130 
    self._oprot.writeMessageEnd()
5131 
    self._oprot.trans.flush()
5132 
 
5133 
  def recv_getProductFeedSubmit(self, ):
5134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5135 
    if mtype == TMessageType.EXCEPTION:
5136 
      x = TApplicationException()
5137 
      x.read(self._iprot)
5138 
      self._iprot.readMessageEnd()
5139 
      raise x
5140 
    result = getProductFeedSubmit_result()
5141 
    result.read(self._iprot)
5142 
    self._iprot.readMessageEnd()
5143 
    if result.success is not None:
5144 
      return result.success
5145 
    if result.cex is not None:
5146 
      raise result.cex
5147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5148 
 
5149 
  def addProductFeedSubmit(self, productFeedSubmit):
5150 
    """
5151 
    Parameters:
5152 
     - productFeedSubmit
5153 
    """
5154 
    self.send_addProductFeedSubmit(productFeedSubmit)
5155 
    return self.recv_addProductFeedSubmit()
5156 
 
5157 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5158 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5159 
    args = addProductFeedSubmit_args()
5160 
    args.productFeedSubmit = productFeedSubmit
5161 
    args.write(self._oprot)
5162 
    self._oprot.writeMessageEnd()
5163 
    self._oprot.trans.flush()
5164 
 
5165 
  def recv_addProductFeedSubmit(self, ):
5166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5167 
    if mtype == TMessageType.EXCEPTION:
5168 
      x = TApplicationException()
5169 
      x.read(self._iprot)
5170 
      self._iprot.readMessageEnd()
5171 
      raise x
5172 
    result = addProductFeedSubmit_result()
5173 
    result.read(self._iprot)
5174 
    self._iprot.readMessageEnd()
5175 
    if result.success is not None:
5176 
      return result.success
5177 
    if result.cex is not None:
5178 
      raise result.cex
5179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5180 
 
5181 
  def updateProductFeedSubmit(self, productFeedSubmit):
5182 
    """
5183 
    Parameters:
5184 
     - productFeedSubmit
5185 
    """
5186 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5187 
    return self.recv_updateProductFeedSubmit()
5188 
 
5189 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5190 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5191 
    args = updateProductFeedSubmit_args()
5192 
    args.productFeedSubmit = productFeedSubmit
5193 
    args.write(self._oprot)
5194 
    self._oprot.writeMessageEnd()
5195 
    self._oprot.trans.flush()
5196 
 
5197 
  def recv_updateProductFeedSubmit(self, ):
5198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5199 
    if mtype == TMessageType.EXCEPTION:
5200 
      x = TApplicationException()
5201 
      x.read(self._iprot)
5202 
      self._iprot.readMessageEnd()
5203 
      raise x
5204 
    result = updateProductFeedSubmit_result()
5205 
    result.read(self._iprot)
5206 
    self._iprot.readMessageEnd()
5207 
    if result.success is not None:
5208 
      return result.success
5209 
    if result.cex is not None:
5210 
      raise result.cex
5211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5212 
 
5213 
  def deleteProductFeedSubmit(self, catalogItemId):
5214 
    """
5215 
    Parameters:
5216 
     - catalogItemId
5217 
    """
5218 
    self.send_deleteProductFeedSubmit(catalogItemId)
5219 
    return self.recv_deleteProductFeedSubmit()
5220 
 
5221 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5222 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5223 
    args = deleteProductFeedSubmit_args()
5224 
    args.catalogItemId = catalogItemId
5225 
    args.write(self._oprot)
5226 
    self._oprot.writeMessageEnd()
5227 
    self._oprot.trans.flush()
5228 
 
5229 
  def recv_deleteProductFeedSubmit(self, ):
5230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5231 
    if mtype == TMessageType.EXCEPTION:
5232 
      x = TApplicationException()
5233 
      x.read(self._iprot)
5234 
      self._iprot.readMessageEnd()
5235 
      raise x
5236 
    result = deleteProductFeedSubmit_result()
5237 
    result.read(self._iprot)
5238 
    self._iprot.readMessageEnd()
5239 
    if result.success is not None:
5240 
      return result.success
5241 
    if result.cex is not None:
5242 
      raise result.cex
5243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5244 
 
5245 
  def getAllProductFeedSubmit(self, ):
5246 
    self.send_getAllProductFeedSubmit()
5247 
    return self.recv_getAllProductFeedSubmit()
5248 
 
5249 
  def send_getAllProductFeedSubmit(self, ):
5250 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5251 
    args = getAllProductFeedSubmit_args()
5252 
    args.write(self._oprot)
5253 
    self._oprot.writeMessageEnd()
5254 
    self._oprot.trans.flush()
5255 
 
5256 
  def recv_getAllProductFeedSubmit(self, ):
5257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5258 
    if mtype == TMessageType.EXCEPTION:
5259 
      x = TApplicationException()
5260 
      x.read(self._iprot)
5261 
      self._iprot.readMessageEnd()
5262 
      raise x
5263 
    result = getAllProductFeedSubmit_result()
5264 
    result.read(self._iprot)
5265 
    self._iprot.readMessageEnd()
5266 
    if result.success is not None:
5267 
      return result.success
5268 
    if result.cex is not None:
5269 
      raise result.cex
5270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5271 
 
9724 kshitij.so 5272 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5273 
    """
5274 
    Parameters:
5275 
     - itemId
5276 
     - sourceId
5277 
    """
5278 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5279 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5280 
 
9724 kshitij.so 5281 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5282 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5283 
    args = getMarketplacedetailsForItem_args()
5284 
    args.itemId = itemId
5285 
    args.sourceId = sourceId
5286 
    args.write(self._oprot)
5287 
    self._oprot.writeMessageEnd()
5288 
    self._oprot.trans.flush()
5289 
 
5290 
  def recv_getMarketplacedetailsForItem(self, ):
5291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5292 
    if mtype == TMessageType.EXCEPTION:
5293 
      x = TApplicationException()
5294 
      x.read(self._iprot)
5295 
      self._iprot.readMessageEnd()
5296 
      raise x
5297 
    result = getMarketplacedetailsForItem_result()
5298 
    result.read(self._iprot)
5299 
    self._iprot.readMessageEnd()
5300 
    if result.success is not None:
5301 
      return result.success
5302 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5303 
 
5304 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5305 
    """
5306 
    Parameters:
5307 
     - marketPlaceItem
5308 
    """
5309 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5310 
    return self.recv_updateMarketplaceAttributesForItem()
5311 
 
5312 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5313 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5314 
    args = updateMarketplaceAttributesForItem_args()
5315 
    args.marketPlaceItem = marketPlaceItem
5316 
    args.write(self._oprot)
5317 
    self._oprot.writeMessageEnd()
5318 
    self._oprot.trans.flush()
5319 
 
5320 
  def recv_updateMarketplaceAttributesForItem(self, ):
5321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5322 
    if mtype == TMessageType.EXCEPTION:
5323 
      x = TApplicationException()
5324 
      x.read(self._iprot)
5325 
      self._iprot.readMessageEnd()
5326 
      raise x
5327 
    result = updateMarketplaceAttributesForItem_result()
5328 
    result.read(self._iprot)
5329 
    self._iprot.readMessageEnd()
5330 
    if result.success is not None:
5331 
      return result.success
5332 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5333 
 
9779 kshitij.so 5334 
  def getCostingForMarketplace(self, source, item_id):
5335 
    """
5336 
    Parameters:
5337 
     - source
5338 
     - item_id
5339 
    """
5340 
    self.send_getCostingForMarketplace(source, item_id)
5341 
    return self.recv_getCostingForMarketplace()
5342 
 
5343 
  def send_getCostingForMarketplace(self, source, item_id):
5344 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5345 
    args = getCostingForMarketplace_args()
5346 
    args.source = source
5347 
    args.item_id = item_id
5348 
    args.write(self._oprot)
5349 
    self._oprot.writeMessageEnd()
5350 
    self._oprot.trans.flush()
5351 
 
5352 
  def recv_getCostingForMarketplace(self, ):
5353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5354 
    if mtype == TMessageType.EXCEPTION:
5355 
      x = TApplicationException()
5356 
      x.read(self._iprot)
5357 
      self._iprot.readMessageEnd()
5358 
      raise x
5359 
    result = getCostingForMarketplace_result()
5360 
    result.read(self._iprot)
5361 
    self._iprot.readMessageEnd()
5362 
    if result.success is not None:
5363 
      return result.success
5364 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5365 
 
9776 vikram.rag 5366 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5367 
    """
5368 
    Parameters:
5369 
     - source
5370 
    """
5371 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5372 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5373 
 
9776 vikram.rag 5374 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5375 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5376 
    args = getMarketPlaceItemsForPriceUpdate_args()
5377 
    args.source = source
5378 
    args.write(self._oprot)
5379 
    self._oprot.writeMessageEnd()
5380 
    self._oprot.trans.flush()
5381 
 
5382 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5384 
    if mtype == TMessageType.EXCEPTION:
5385 
      x = TApplicationException()
5386 
      x.read(self._iprot)
5387 
      self._iprot.readMessageEnd()
5388 
      raise x
5389 
    result = getMarketPlaceItemsForPriceUpdate_result()
5390 
    result.read(self._iprot)
5391 
    self._iprot.readMessageEnd()
5392 
    if result.success is not None:
5393 
      return result.success
5394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5395 
 
9816 kshitij.so 5396 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5397 
    """
5398 
    Parameters:
5399 
     - skulist
5400 
     - timestamp
9816 kshitij.so 5401 
     - source
9776 vikram.rag 5402 
    """
9816 kshitij.so 5403 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5404 
    self.recv_updateMarketPlacePriceUpdateStatus()
5405 
 
9816 kshitij.so 5406 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5407 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5408 
    args = updateMarketPlacePriceUpdateStatus_args()
5409 
    args.skulist = skulist
5410 
    args.timestamp = timestamp
9816 kshitij.so 5411 
    args.source = source
9776 vikram.rag 5412 
    args.write(self._oprot)
5413 
    self._oprot.writeMessageEnd()
5414 
    self._oprot.trans.flush()
5415 
 
5416 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5418 
    if mtype == TMessageType.EXCEPTION:
5419 
      x = TApplicationException()
5420 
      x.read(self._iprot)
5421 
      self._iprot.readMessageEnd()
5422 
      raise x
5423 
    result = updateMarketPlacePriceUpdateStatus_result()
5424 
    result.read(self._iprot)
5425 
    self._iprot.readMessageEnd()
5426 
    return
5427 
 
9861 rajveer 5428 
  def updateItemHoldInventory(self, itemHoldMap):
5429 
    """
5430 
    Parameters:
5431 
     - itemHoldMap
5432 
    """
5433 
    self.send_updateItemHoldInventory(itemHoldMap)
5434 
    self.recv_updateItemHoldInventory()
9776 vikram.rag 5435 
 
9861 rajveer 5436 
  def send_updateItemHoldInventory(self, itemHoldMap):
5437 
    self._oprot.writeMessageBegin('updateItemHoldInventory', TMessageType.CALL, self._seqid)
5438 
    args = updateItemHoldInventory_args()
5439 
    args.itemHoldMap = itemHoldMap
5440 
    args.write(self._oprot)
5441 
    self._oprot.writeMessageEnd()
5442 
    self._oprot.trans.flush()
5443 
 
5444 
  def recv_updateItemHoldInventory(self, ):
5445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5446 
    if mtype == TMessageType.EXCEPTION:
5447 
      x = TApplicationException()
5448 
      x.read(self._iprot)
5449 
      self._iprot.readMessageEnd()
5450 
      raise x
5451 
    result = updateItemHoldInventory_result()
5452 
    result.read(self._iprot)
5453 
    self._iprot.readMessageEnd()
5454 
    return
5455 
 
9895 vikram.rag 5456 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5457 
    """
5458 
    Parameters:
5459 
     - item_id
5460 
     - vendor_id
5461 
     - nlc
5462 
    """
5463 
    self.send_updateNlcAtMarketplaces(item_id, vendor_id, nlc)
5464 
    self.recv_updateNlcAtMarketplaces()
9861 rajveer 5465 
 
9895 vikram.rag 5466 
  def send_updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5467 
    self._oprot.writeMessageBegin('updateNlcAtMarketplaces', TMessageType.CALL, self._seqid)
5468 
    args = updateNlcAtMarketplaces_args()
5469 
    args.item_id = item_id
5470 
    args.vendor_id = vendor_id
5471 
    args.nlc = nlc
5472 
    args.write(self._oprot)
5473 
    self._oprot.writeMessageEnd()
5474 
    self._oprot.trans.flush()
5475 
 
5476 
  def recv_updateNlcAtMarketplaces(self, ):
5477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5478 
    if mtype == TMessageType.EXCEPTION:
5479 
      x = TApplicationException()
5480 
      x.read(self._iprot)
5481 
      self._iprot.readMessageEnd()
5482 
      raise x
5483 
    result = updateNlcAtMarketplaces_result()
5484 
    result.read(self._iprot)
5485 
    self._iprot.readMessageEnd()
5486 
    return
5487 
 
9945 vikram.rag 5488 
  def getAllFlipkartItems(self, ):
5489 
    self.send_getAllFlipkartItems()
5490 
    return self.recv_getAllFlipkartItems()
9895 vikram.rag 5491 
 
9945 vikram.rag 5492 
  def send_getAllFlipkartItems(self, ):
5493 
    self._oprot.writeMessageBegin('getAllFlipkartItems', TMessageType.CALL, self._seqid)
5494 
    args = getAllFlipkartItems_args()
5495 
    args.write(self._oprot)
5496 
    self._oprot.writeMessageEnd()
5497 
    self._oprot.trans.flush()
5498 
 
5499 
  def recv_getAllFlipkartItems(self, ):
5500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5501 
    if mtype == TMessageType.EXCEPTION:
5502 
      x = TApplicationException()
5503 
      x.read(self._iprot)
5504 
      self._iprot.readMessageEnd()
5505 
      raise x
5506 
    result = getAllFlipkartItems_result()
5507 
    result.read(self._iprot)
5508 
    self._iprot.readMessageEnd()
5509 
    if result.success is not None:
5510 
      return result.success
5511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartItems failed: unknown result");
5512 
 
5513 
 
5944 mandeep.dh 5514 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
5515 
  def __init__(self, handler):
5516 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
5517 
    self._processMap["addItem"] = Processor.process_addItem
5518 
    self._processMap["updateItem"] = Processor.process_updateItem
5519 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 5520 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 5521 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
5522 
    self._processMap["startItemOn"] = Processor.process_startItemOn
5523 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
5524 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
5525 
    self._processMap["getItem"] = Processor.process_getItem
5526 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
5527 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
5528 
    self._processMap["getAllItems"] = Processor.process_getAllItems
5529 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
5530 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
5531 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
5532 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
5533 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
5534 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
5535 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
5536 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
5537 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
5538 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
5539 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
5540 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
5541 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
5542 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
5543 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
5544 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
5545 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
5546 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
5547 
    self._processMap["addCategory"] = Processor.process_addCategory
5548 
    self._processMap["getCategory"] = Processor.process_getCategory
5549 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
5550 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
5551 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 5552 
    self._processMap["addTag"] = Processor.process_addTag
5553 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
5554 
    self._processMap["deleteTag"] = Processor.process_deleteTag
5555 
    self._processMap["getAllTags"] = Processor.process_getAllTags
5556 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 5557 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 5558 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 5559 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 5560 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
5561 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
5562 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
5563 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 5564 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 5565 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 5566 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
5567 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 5568 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
5569 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
5570 
    self._processMap["addCampaign"] = Processor.process_addCampaign
5571 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
5572 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
5573 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 5574 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 5575 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
5576 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
5577 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
5578 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
5579 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
5580 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
5581 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
5582 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
5583 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
5584 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
5585 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
5586 
    self._processMap["getAllSources"] = Processor.process_getAllSources
5587 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
5588 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
5589 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
5590 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
5591 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
5592 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
5593 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
5594 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
5595 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
5596 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
5597 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
5598 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
5599 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
5600 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 5601 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
5602 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 5603 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 5604 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 5605 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
5606 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 5607 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 5608 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 5609 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
5610 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 5611 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
5612 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 5613 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 5614 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 5615 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 5616 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 5617 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
5618 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
5619 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 5620 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
5621 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
5622 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 5623 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
5624 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
5625 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 5626 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 5627 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 5628 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 5629 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
5630 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 5631 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
5632 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
5633 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 5634 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 5635 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 5636 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
5637 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 5638 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 5639 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
5640 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 5641 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 5642 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 5643 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
5644 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
5645 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
5646 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 5647 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 5648 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 5649 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
5650 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
5651 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
5652 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
5653 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 5654 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
5655 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 5656 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 5657 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
5658 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
9861 rajveer 5659 
    self._processMap["updateItemHoldInventory"] = Processor.process_updateItemHoldInventory
9895 vikram.rag 5660 
    self._processMap["updateNlcAtMarketplaces"] = Processor.process_updateNlcAtMarketplaces
9945 vikram.rag 5661 
    self._processMap["getAllFlipkartItems"] = Processor.process_getAllFlipkartItems
5944 mandeep.dh 5662 
 
5663 
  def process(self, iprot, oprot):
5664 
    (name, type, seqid) = iprot.readMessageBegin()
5665 
    if name not in self._processMap:
5666 
      iprot.skip(TType.STRUCT)
5667 
      iprot.readMessageEnd()
5668 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5669 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5670 
      x.write(oprot)
5671 
      oprot.writeMessageEnd()
5672 
      oprot.trans.flush()
5673 
      return
5674 
    else:
5675 
      self._processMap[name](self, seqid, iprot, oprot)
5676 
    return True
5677 
 
5678 
  def process_addItem(self, seqid, iprot, oprot):
5679 
    args = addItem_args()
5680 
    args.read(iprot)
5681 
    iprot.readMessageEnd()
5682 
    result = addItem_result()
5683 
    try:
5684 
      result.success = self._handler.addItem(args.item)
5685 
    except CatalogServiceException, cex:
5686 
      result.cex = cex
5687 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
5688 
    result.write(oprot)
5689 
    oprot.writeMessageEnd()
5690 
    oprot.trans.flush()
5691 
 
5692 
  def process_updateItem(self, seqid, iprot, oprot):
5693 
    args = updateItem_args()
5694 
    args.read(iprot)
5695 
    iprot.readMessageEnd()
5696 
    result = updateItem_result()
5697 
    try:
5698 
      result.success = self._handler.updateItem(args.item)
5699 
    except CatalogServiceException, cex:
5700 
      result.cex = cex
5701 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
5702 
    result.write(oprot)
5703 
    oprot.writeMessageEnd()
5704 
    oprot.trans.flush()
5705 
 
5706 
  def process_isActive(self, seqid, iprot, oprot):
5707 
    args = isActive_args()
5708 
    args.read(iprot)
5709 
    iprot.readMessageEnd()
5710 
    result = isActive_result()
5711 
    try:
5712 
      result.success = self._handler.isActive(args.itemId)
5713 
    except CatalogServiceException, isex:
5714 
      result.isex = isex
5715 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
5716 
    result.write(oprot)
5717 
    oprot.writeMessageEnd()
5718 
    oprot.trans.flush()
5719 
 
7438 amit.gupta 5720 
  def process_getItemsStatus(self, seqid, iprot, oprot):
5721 
    args = getItemsStatus_args()
5722 
    args.read(iprot)
5723 
    iprot.readMessageEnd()
5724 
    result = getItemsStatus_result()
5725 
    try:
5726 
      result.success = self._handler.getItemsStatus(args.itemIds)
5727 
    except CatalogServiceException, isex:
5728 
      result.isex = isex
5729 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
5730 
    result.write(oprot)
5731 
    oprot.writeMessageEnd()
5732 
    oprot.trans.flush()
5733 
 
5944 mandeep.dh 5734 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
5735 
    args = getItemStatusDescription_args()
5736 
    args.read(iprot)
5737 
    iprot.readMessageEnd()
5738 
    result = getItemStatusDescription_result()
5739 
    try:
5740 
      result.success = self._handler.getItemStatusDescription(args.itemId)
5741 
    except CatalogServiceException, isex:
5742 
      result.isex = isex
5743 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
5744 
    result.write(oprot)
5745 
    oprot.writeMessageEnd()
5746 
    oprot.trans.flush()
5747 
 
5748 
  def process_startItemOn(self, seqid, iprot, oprot):
5749 
    args = startItemOn_args()
5750 
    args.read(iprot)
5751 
    iprot.readMessageEnd()
5752 
    result = startItemOn_result()
5753 
    try:
5754 
      self._handler.startItemOn(args.item_id, args.timestamp)
5755 
    except CatalogServiceException, cex:
5756 
      result.cex = cex
5757 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
5758 
    result.write(oprot)
5759 
    oprot.writeMessageEnd()
5760 
    oprot.trans.flush()
5761 
 
5762 
  def process_retireItemOn(self, seqid, iprot, oprot):
5763 
    args = retireItemOn_args()
5764 
    args.read(iprot)
5765 
    iprot.readMessageEnd()
5766 
    result = retireItemOn_result()
5767 
    try:
5768 
      self._handler.retireItemOn(args.item_id, args.timestamp)
5769 
    except CatalogServiceException, cex:
5770 
      result.cex = cex
5771 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
5772 
    result.write(oprot)
5773 
    oprot.writeMessageEnd()
5774 
    oprot.trans.flush()
5775 
 
5776 
  def process_changeItemStatus(self, seqid, iprot, oprot):
5777 
    args = changeItemStatus_args()
5778 
    args.read(iprot)
5779 
    iprot.readMessageEnd()
5780 
    result = changeItemStatus_result()
5781 
    try:
5782 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
5783 
    except CatalogServiceException, cex:
5784 
      result.cex = cex
5785 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
5786 
    result.write(oprot)
5787 
    oprot.writeMessageEnd()
5788 
    oprot.trans.flush()
5789 
 
5790 
  def process_getItem(self, seqid, iprot, oprot):
5791 
    args = getItem_args()
5792 
    args.read(iprot)
5793 
    iprot.readMessageEnd()
5794 
    result = getItem_result()
5795 
    try:
5796 
      result.success = self._handler.getItem(args.item_id)
5797 
    except CatalogServiceException, cex:
5798 
      result.cex = cex
5799 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
5800 
    result.write(oprot)
5801 
    oprot.writeMessageEnd()
5802 
    oprot.trans.flush()
5803 
 
5804 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
5805 
    args = getItemsByCatalogId_args()
5806 
    args.read(iprot)
5807 
    iprot.readMessageEnd()
5808 
    result = getItemsByCatalogId_result()
5809 
    try:
5810 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
5811 
    except CatalogServiceException, cex:
5812 
      result.cex = cex
5813 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
5814 
    result.write(oprot)
5815 
    oprot.writeMessageEnd()
5816 
    oprot.trans.flush()
5817 
 
5818 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
5819 
    args = getValidItemsByCatalogId_args()
5820 
    args.read(iprot)
5821 
    iprot.readMessageEnd()
5822 
    result = getValidItemsByCatalogId_result()
5823 
    try:
5824 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
5825 
    except CatalogServiceException, cex:
5826 
      result.cex = cex
5827 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
5828 
    result.write(oprot)
5829 
    oprot.writeMessageEnd()
5830 
    oprot.trans.flush()
5831 
 
5832 
  def process_getAllItems(self, seqid, iprot, oprot):
5833 
    args = getAllItems_args()
5834 
    args.read(iprot)
5835 
    iprot.readMessageEnd()
5836 
    result = getAllItems_result()
5837 
    try:
5838 
      result.success = self._handler.getAllItems(args.isActive)
5839 
    except CatalogServiceException, cex:
5840 
      result.cex = cex
5841 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
5842 
    result.write(oprot)
5843 
    oprot.writeMessageEnd()
5844 
    oprot.trans.flush()
5845 
 
5846 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
5847 
    args = getAllItemsByStatus_args()
5848 
    args.read(iprot)
5849 
    iprot.readMessageEnd()
5850 
    result = getAllItemsByStatus_result()
5851 
    try:
5852 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
5853 
    except CatalogServiceException, cex:
5854 
      result.cex = cex
5855 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
5856 
    result.write(oprot)
5857 
    oprot.writeMessageEnd()
5858 
    oprot.trans.flush()
5859 
 
5860 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
5861 
    args = markItemAsContentComplete_args()
5862 
    args.read(iprot)
5863 
    iprot.readMessageEnd()
5864 
    result = markItemAsContentComplete_result()
5865 
    try:
9253 rajveer 5866 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 5867 
    except CatalogServiceException, cex:
5868 
      result.cex = cex
5869 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
5870 
    result.write(oprot)
5871 
    oprot.writeMessageEnd()
5872 
    oprot.trans.flush()
5873 
 
5874 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
5875 
    args = getAllItemsInRange_args()
5876 
    args.read(iprot)
5877 
    iprot.readMessageEnd()
5878 
    result = getAllItemsInRange_result()
5879 
    try:
5880 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
5881 
    except CatalogServiceException, cex:
5882 
      result.cex = cex
5883 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
5884 
    result.write(oprot)
5885 
    oprot.writeMessageEnd()
5886 
    oprot.trans.flush()
5887 
 
5888 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
5889 
    args = getAllItemsByStatusInRange_args()
5890 
    args.read(iprot)
5891 
    iprot.readMessageEnd()
5892 
    result = getAllItemsByStatusInRange_result()
5893 
    try:
5894 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
5895 
    except CatalogServiceException, cex:
5896 
      result.cex = cex
5897 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
5898 
    result.write(oprot)
5899 
    oprot.writeMessageEnd()
5900 
    oprot.trans.flush()
5901 
 
5902 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
5903 
    args = getItemCountByStatus_args()
5904 
    args.read(iprot)
5905 
    iprot.readMessageEnd()
5906 
    result = getItemCountByStatus_result()
5907 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
5908 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
5909 
    result.write(oprot)
5910 
    oprot.writeMessageEnd()
5911 
    oprot.trans.flush()
5912 
 
5913 
  def process_getBestSellers(self, seqid, iprot, oprot):
5914 
    args = getBestSellers_args()
5915 
    args.read(iprot)
5916 
    iprot.readMessageEnd()
5917 
    result = getBestSellers_result()
5918 
    try:
5919 
      result.success = self._handler.getBestSellers()
5920 
    except CatalogServiceException, isex:
5921 
      result.isex = isex
5922 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
5923 
    result.write(oprot)
5924 
    oprot.writeMessageEnd()
5925 
    oprot.trans.flush()
5926 
 
5927 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
5928 
    args = getBestSellersCatalogIds_args()
5929 
    args.read(iprot)
5930 
    iprot.readMessageEnd()
5931 
    result = getBestSellersCatalogIds_result()
5932 
    try:
5933 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5934 
    except CatalogServiceException, cex:
5935 
      result.cex = cex
5936 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
5937 
    result.write(oprot)
5938 
    oprot.writeMessageEnd()
5939 
    oprot.trans.flush()
5940 
 
5941 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
5942 
    args = getBestSellersCount_args()
5943 
    args.read(iprot)
5944 
    iprot.readMessageEnd()
5945 
    result = getBestSellersCount_result()
5946 
    try:
5947 
      result.success = self._handler.getBestSellersCount()
5948 
    except CatalogServiceException, cex:
5949 
      result.cex = cex
5950 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
5951 
    result.write(oprot)
5952 
    oprot.writeMessageEnd()
5953 
    oprot.trans.flush()
5954 
 
5955 
  def process_getBestDeals(self, seqid, iprot, oprot):
5956 
    args = getBestDeals_args()
5957 
    args.read(iprot)
5958 
    iprot.readMessageEnd()
5959 
    result = getBestDeals_result()
5960 
    try:
5961 
      result.success = self._handler.getBestDeals()
5962 
    except CatalogServiceException, isex:
5963 
      result.isex = isex
5964 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
5965 
    result.write(oprot)
5966 
    oprot.writeMessageEnd()
5967 
    oprot.trans.flush()
5968 
 
5969 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
5970 
    args = getBestDealsCatalogIds_args()
5971 
    args.read(iprot)
5972 
    iprot.readMessageEnd()
5973 
    result = getBestDealsCatalogIds_result()
5974 
    try:
5975 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5976 
    except CatalogServiceException, cex:
5977 
      result.cex = cex
5978 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
5979 
    result.write(oprot)
5980 
    oprot.writeMessageEnd()
5981 
    oprot.trans.flush()
5982 
 
5983 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
5984 
    args = getBestDealsCount_args()
5985 
    args.read(iprot)
5986 
    iprot.readMessageEnd()
5987 
    result = getBestDealsCount_result()
5988 
    try:
5989 
      result.success = self._handler.getBestDealsCount()
5990 
    except CatalogServiceException, cex:
5991 
      result.cex = cex
5992 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
5993 
    result.write(oprot)
5994 
    oprot.writeMessageEnd()
5995 
    oprot.trans.flush()
5996 
 
5997 
  def process_getComingSoon(self, seqid, iprot, oprot):
5998 
    args = getComingSoon_args()
5999 
    args.read(iprot)
6000 
    iprot.readMessageEnd()
6001 
    result = getComingSoon_result()
6002 
    try:
6003 
      result.success = self._handler.getComingSoon()
6004 
    except CatalogServiceException, isex:
6005 
      result.isex = isex
6006 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
6007 
    result.write(oprot)
6008 
    oprot.writeMessageEnd()
6009 
    oprot.trans.flush()
6010 
 
6011 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
6012 
    args = getComingSoonCatalogIds_args()
6013 
    args.read(iprot)
6014 
    iprot.readMessageEnd()
6015 
    result = getComingSoonCatalogIds_result()
6016 
    try:
6017 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6018 
    except CatalogServiceException, cex:
6019 
      result.cex = cex
6020 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
6021 
    result.write(oprot)
6022 
    oprot.writeMessageEnd()
6023 
    oprot.trans.flush()
6024 
 
6025 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
6026 
    args = getComingSoonCount_args()
6027 
    args.read(iprot)
6028 
    iprot.readMessageEnd()
6029 
    result = getComingSoonCount_result()
6030 
    try:
6031 
      result.success = self._handler.getComingSoonCount()
6032 
    except CatalogServiceException, cex:
6033 
      result.cex = cex
6034 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
6035 
    result.write(oprot)
6036 
    oprot.writeMessageEnd()
6037 
    oprot.trans.flush()
6038 
 
6039 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
6040 
    args = getLatestArrivals_args()
6041 
    args.read(iprot)
6042 
    iprot.readMessageEnd()
6043 
    result = getLatestArrivals_result()
6044 
    try:
6045 
      result.success = self._handler.getLatestArrivals()
6046 
    except CatalogServiceException, isex:
6047 
      result.isex = isex
6048 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
6049 
    result.write(oprot)
6050 
    oprot.writeMessageEnd()
6051 
    oprot.trans.flush()
6052 
 
6053 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
6054 
    args = getLatestArrivalsCatalogIds_args()
6055 
    args.read(iprot)
6056 
    iprot.readMessageEnd()
6057 
    result = getLatestArrivalsCatalogIds_result()
6058 
    try:
6059 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
6060 
    except CatalogServiceException, cex:
6061 
      result.cex = cex
6062 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
6063 
    result.write(oprot)
6064 
    oprot.writeMessageEnd()
6065 
    oprot.trans.flush()
6066 
 
6067 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
6068 
    args = getLatestArrivalsCount_args()
6069 
    args.read(iprot)
6070 
    iprot.readMessageEnd()
6071 
    result = getLatestArrivalsCount_result()
6072 
    try:
6073 
      result.success = self._handler.getLatestArrivalsCount()
6074 
    except CatalogServiceException, cex:
6075 
      result.cex = cex
6076 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
6077 
    result.write(oprot)
6078 
    oprot.writeMessageEnd()
6079 
    oprot.trans.flush()
6080 
 
6081 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
6082 
    args = generateNewEntityID_args()
6083 
    args.read(iprot)
6084 
    iprot.readMessageEnd()
6085 
    result = generateNewEntityID_result()
6086 
    result.success = self._handler.generateNewEntityID()
6087 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
6088 
    result.write(oprot)
6089 
    oprot.writeMessageEnd()
6090 
    oprot.trans.flush()
6091 
 
6092 
  def process_addCategory(self, seqid, iprot, oprot):
6093 
    args = addCategory_args()
6094 
    args.read(iprot)
6095 
    iprot.readMessageEnd()
6096 
    result = addCategory_result()
6097 
    result.success = self._handler.addCategory(args.category)
6098 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
6099 
    result.write(oprot)
6100 
    oprot.writeMessageEnd()
6101 
    oprot.trans.flush()
6102 
 
6103 
  def process_getCategory(self, seqid, iprot, oprot):
6104 
    args = getCategory_args()
6105 
    args.read(iprot)
6106 
    iprot.readMessageEnd()
6107 
    result = getCategory_result()
6108 
    result.success = self._handler.getCategory(args.id)
6109 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
6110 
    result.write(oprot)
6111 
    oprot.writeMessageEnd()
6112 
    oprot.trans.flush()
6113 
 
6114 
  def process_getAllCategories(self, seqid, iprot, oprot):
6115 
    args = getAllCategories_args()
6116 
    args.read(iprot)
6117 
    iprot.readMessageEnd()
6118 
    result = getAllCategories_result()
6119 
    result.success = self._handler.getAllCategories()
6120 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
6121 
    result.write(oprot)
6122 
    oprot.writeMessageEnd()
6123 
    oprot.trans.flush()
6124 
 
6125 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
6126 
    args = getAllSimilarItems_args()
6127 
    args.read(iprot)
6128 
    iprot.readMessageEnd()
6129 
    result = getAllSimilarItems_result()
6130 
    result.success = self._handler.getAllSimilarItems(args.itemId)
6131 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
6132 
    result.write(oprot)
6133 
    oprot.writeMessageEnd()
6134 
    oprot.trans.flush()
6135 
 
6136 
  def process_addSimilarItem(self, seqid, iprot, oprot):
6137 
    args = addSimilarItem_args()
6138 
    args.read(iprot)
6139 
    iprot.readMessageEnd()
6140 
    result = addSimilarItem_result()
6141 
    try:
6142 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
6143 
    except CatalogServiceException, cex:
6144 
      result.cex = cex
6145 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
6146 
    result.write(oprot)
6147 
    oprot.writeMessageEnd()
6148 
    oprot.trans.flush()
6149 
 
6512 kshitij.so 6150 
  def process_addTag(self, seqid, iprot, oprot):
6151 
    args = addTag_args()
6152 
    args.read(iprot)
6153 
    iprot.readMessageEnd()
6154 
    result = addTag_result()
6155 
    result.success = self._handler.addTag(args.displayName, args.itemId)
6156 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
6157 
    result.write(oprot)
6158 
    oprot.writeMessageEnd()
6159 
    oprot.trans.flush()
6160 
 
6161 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
6162 
    args = deleteEntityTag_args()
6163 
    args.read(iprot)
6164 
    iprot.readMessageEnd()
6165 
    result = deleteEntityTag_result()
6166 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
6167 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
6168 
    result.write(oprot)
6169 
    oprot.writeMessageEnd()
6170 
    oprot.trans.flush()
6171 
 
6172 
  def process_deleteTag(self, seqid, iprot, oprot):
6173 
    args = deleteTag_args()
6174 
    args.read(iprot)
6175 
    iprot.readMessageEnd()
6176 
    result = deleteTag_result()
6177 
    result.success = self._handler.deleteTag(args.displayName)
6178 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
6179 
    result.write(oprot)
6180 
    oprot.writeMessageEnd()
6181 
    oprot.trans.flush()
6182 
 
6183 
  def process_getAllTags(self, seqid, iprot, oprot):
6184 
    args = getAllTags_args()
6185 
    args.read(iprot)
6186 
    iprot.readMessageEnd()
6187 
    result = getAllTags_result()
6188 
    result.success = self._handler.getAllTags()
6189 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
6190 
    result.write(oprot)
6191 
    oprot.writeMessageEnd()
6192 
    oprot.trans.flush()
6193 
 
6194 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
6195 
    args = getAllEntitiesByTagName_args()
6196 
    args.read(iprot)
6197 
    iprot.readMessageEnd()
6198 
    result = getAllEntitiesByTagName_result()
6199 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
6200 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
6201 
    result.write(oprot)
6202 
    oprot.writeMessageEnd()
6203 
    oprot.trans.flush()
6204 
 
6845 amit.gupta 6205 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
6206 
    args = getAllEntityTags_args()
6207 
    args.read(iprot)
6208 
    iprot.readMessageEnd()
6209 
    result = getAllEntityTags_result()
6210 
    result.success = self._handler.getAllEntityTags()
6211 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
6212 
    result.write(oprot)
6213 
    oprot.writeMessageEnd()
6214 
    oprot.trans.flush()
6215 
 
6850 kshitij.so 6216 
  def process_addBanner(self, seqid, iprot, oprot):
6217 
    args = addBanner_args()
6218 
    args.read(iprot)
6219 
    iprot.readMessageEnd()
6220 
    result = addBanner_result()
8590 kshitij.so 6221 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 6222 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
6223 
    result.write(oprot)
6224 
    oprot.writeMessageEnd()
6225 
    oprot.trans.flush()
6226 
 
8579 kshitij.so 6227 
  def process_updateBanner(self, seqid, iprot, oprot):
6228 
    args = updateBanner_args()
6229 
    args.read(iprot)
6230 
    iprot.readMessageEnd()
6231 
    result = updateBanner_result()
6232 
    result.success = self._handler.updateBanner(args.banner)
6233 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
6234 
    result.write(oprot)
6235 
    oprot.writeMessageEnd()
6236 
    oprot.trans.flush()
6237 
 
6850 kshitij.so 6238 
  def process_getAllBanners(self, seqid, iprot, oprot):
6239 
    args = getAllBanners_args()
6240 
    args.read(iprot)
6241 
    iprot.readMessageEnd()
6242 
    result = getAllBanners_result()
6243 
    result.success = self._handler.getAllBanners()
6244 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
6245 
    result.write(oprot)
6246 
    oprot.writeMessageEnd()
6247 
    oprot.trans.flush()
6248 
 
6249 
  def process_deleteBanner(self, seqid, iprot, oprot):
6250 
    args = deleteBanner_args()
6251 
    args.read(iprot)
6252 
    iprot.readMessageEnd()
6253 
    result = deleteBanner_result()
9155 kshitij.so 6254 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 6255 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
6256 
    result.write(oprot)
6257 
    oprot.writeMessageEnd()
6258 
    oprot.trans.flush()
6259 
 
6260 
  def process_getBannerDetails(self, seqid, iprot, oprot):
6261 
    args = getBannerDetails_args()
6262 
    args.read(iprot)
6263 
    iprot.readMessageEnd()
6264 
    result = getBannerDetails_result()
9155 kshitij.so 6265 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 6266 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
6267 
    result.write(oprot)
6268 
    oprot.writeMessageEnd()
6269 
    oprot.trans.flush()
6270 
 
6271 
  def process_getActiveBanners(self, seqid, iprot, oprot):
6272 
    args = getActiveBanners_args()
6273 
    args.read(iprot)
6274 
    iprot.readMessageEnd()
6275 
    result = getActiveBanners_result()
6276 
    result.success = self._handler.getActiveBanners()
6277 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
6278 
    result.write(oprot)
6279 
    oprot.writeMessageEnd()
6280 
    oprot.trans.flush()
6281 
 
6849 kshitij.so 6282 
  def process_addBannerMap(self, seqid, iprot, oprot):
6283 
    args = addBannerMap_args()
6284 
    args.read(iprot)
6285 
    iprot.readMessageEnd()
6286 
    result = addBannerMap_result()
8579 kshitij.so 6287 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 6288 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
6289 
    result.write(oprot)
6290 
    oprot.writeMessageEnd()
6291 
    oprot.trans.flush()
6292 
 
8579 kshitij.so 6293 
  def process_updateBannerMap(self, seqid, iprot, oprot):
6294 
    args = updateBannerMap_args()
6295 
    args.read(iprot)
6296 
    iprot.readMessageEnd()
6297 
    result = updateBannerMap_result()
6298 
    result.success = self._handler.updateBannerMap(args.bannerMap)
6299 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
6300 
    result.write(oprot)
6301 
    oprot.writeMessageEnd()
6302 
    oprot.trans.flush()
6303 
 
6849 kshitij.so 6304 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
6305 
    args = deleteBannerMap_args()
6306 
    args.read(iprot)
6307 
    iprot.readMessageEnd()
6308 
    result = deleteBannerMap_result()
6309 
    result.success = self._handler.deleteBannerMap(args.bannerName)
6310 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
6311 
    result.write(oprot)
6312 
    oprot.writeMessageEnd()
6313 
    oprot.trans.flush()
6314 
 
6315 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
6316 
    args = getBannerMapDetails_args()
6317 
    args.read(iprot)
6318 
    iprot.readMessageEnd()
6319 
    result = getBannerMapDetails_result()
9155 kshitij.so 6320 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 6321 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
6322 
    result.write(oprot)
6323 
    oprot.writeMessageEnd()
6324 
    oprot.trans.flush()
6325 
 
8579 kshitij.so 6326 
  def process_addBannerUri(self, seqid, iprot, oprot):
6327 
    args = addBannerUri_args()
6328 
    args.read(iprot)
6329 
    iprot.readMessageEnd()
6330 
    result = addBannerUri_result()
6331 
    self._handler.addBannerUri(args.bannerUriMappings)
6332 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
6333 
    result.write(oprot)
6334 
    oprot.writeMessageEnd()
6335 
    oprot.trans.flush()
6336 
 
6337 
  def process_getUriMapping(self, seqid, iprot, oprot):
6338 
    args = getUriMapping_args()
6339 
    args.read(iprot)
6340 
    iprot.readMessageEnd()
6341 
    result = getUriMapping_result()
9155 kshitij.so 6342 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 6343 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
6344 
    result.write(oprot)
6345 
    oprot.writeMessageEnd()
6346 
    oprot.trans.flush()
6347 
 
6348 
  def process_addCampaign(self, seqid, iprot, oprot):
6349 
    args = addCampaign_args()
6350 
    args.read(iprot)
6351 
    iprot.readMessageEnd()
6352 
    result = addCampaign_result()
6353 
    self._handler.addCampaign(args.campaign)
6354 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
6355 
    result.write(oprot)
6356 
    oprot.writeMessageEnd()
6357 
    oprot.trans.flush()
6358 
 
6359 
  def process_getCampaigns(self, seqid, iprot, oprot):
6360 
    args = getCampaigns_args()
6361 
    args.read(iprot)
6362 
    iprot.readMessageEnd()
6363 
    result = getCampaigns_result()
6364 
    result.success = self._handler.getCampaigns(args.campaignName)
6365 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
6366 
    result.write(oprot)
6367 
    oprot.writeMessageEnd()
6368 
    oprot.trans.flush()
6369 
 
6370 
  def process_deleteCampaign(self, seqid, iprot, oprot):
6371 
    args = deleteCampaign_args()
6372 
    args.read(iprot)
6373 
    iprot.readMessageEnd()
6374 
    result = deleteCampaign_result()
6375 
    self._handler.deleteCampaign(args.campaignId)
6376 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
6377 
    result.write(oprot)
6378 
    oprot.writeMessageEnd()
6379 
    oprot.trans.flush()
6380 
 
6381 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
6382 
    args = getAllCampaigns_args()
6383 
    args.read(iprot)
6384 
    iprot.readMessageEnd()
6385 
    result = getAllCampaigns_result()
6386 
    result.success = self._handler.getAllCampaigns()
6387 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
6388 
    result.write(oprot)
6389 
    oprot.writeMessageEnd()
6390 
    oprot.trans.flush()
6391 
 
9155 kshitij.so 6392 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
6393 
    args = getActiveBannersForMobileSite_args()
6394 
    args.read(iprot)
6395 
    iprot.readMessageEnd()
6396 
    result = getActiveBannersForMobileSite_result()
6397 
    result.success = self._handler.getActiveBannersForMobileSite()
6398 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
6399 
    result.write(oprot)
6400 
    oprot.writeMessageEnd()
6401 
    oprot.trans.flush()
6402 
 
5944 mandeep.dh 6403 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
6404 
    args = deleteSimilarItem_args()
6405 
    args.read(iprot)
6406 
    iprot.readMessageEnd()
6407 
    result = deleteSimilarItem_result()
6408 
    try:
6409 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
6410 
    except CatalogServiceException, cex:
6411 
      result.cex = cex
6412 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
6413 
    result.write(oprot)
6414 
    oprot.writeMessageEnd()
6415 
    oprot.trans.flush()
6416 
 
6417 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
6418 
    args = checkSimilarItem_args()
6419 
    args.read(iprot)
6420 
    iprot.readMessageEnd()
6421 
    result = checkSimilarItem_result()
6422 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
6423 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
6424 
    result.write(oprot)
6425 
    oprot.writeMessageEnd()
6426 
    oprot.trans.flush()
6427 
 
6428 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
6429 
    args = validateRiskyStatus_args()
6430 
    args.read(iprot)
6431 
    iprot.readMessageEnd()
6432 
    result = validateRiskyStatus_result()
6433 
    self._handler.validateRiskyStatus(args.itemId)
6434 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
6435 
    result.write(oprot)
6436 
    oprot.writeMessageEnd()
6437 
    oprot.trans.flush()
6438 
 
6439 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
6440 
    args = changeItemRiskyFlag_args()
6441 
    args.read(iprot)
6442 
    iprot.readMessageEnd()
6443 
    result = changeItemRiskyFlag_result()
6444 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
6445 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
6446 
    result.write(oprot)
6447 
    oprot.writeMessageEnd()
6448 
    oprot.trans.flush()
6449 
 
6450 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
6451 
    args = getItemsByRiskyFlag_args()
6452 
    args.read(iprot)
6453 
    iprot.readMessageEnd()
6454 
    result = getItemsByRiskyFlag_result()
6455 
    result.success = self._handler.getItemsByRiskyFlag()
6456 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
6457 
    result.write(oprot)
6458 
    oprot.writeMessageEnd()
6459 
    oprot.trans.flush()
6460 
 
6461 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
6462 
    args = getItemsForMasterSheet_args()
6463 
    args.read(iprot)
6464 
    iprot.readMessageEnd()
6465 
    result = getItemsForMasterSheet_result()
6466 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
6467 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
6468 
    result.write(oprot)
6469 
    oprot.writeMessageEnd()
6470 
    oprot.trans.flush()
6471 
 
6472 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
6473 
    args = getSimilarItemsCatalogIds_args()
6474 
    args.read(iprot)
6475 
    iprot.readMessageEnd()
6476 
    result = getSimilarItemsCatalogIds_result()
6477 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
6478 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
6479 
    result.write(oprot)
6480 
    oprot.writeMessageEnd()
6481 
    oprot.trans.flush()
6482 
 
6483 
  def process_addProductNotification(self, seqid, iprot, oprot):
6484 
    args = addProductNotification_args()
6485 
    args.read(iprot)
6486 
    iprot.readMessageEnd()
6487 
    result = addProductNotification_result()
6488 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
6489 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
6490 
    result.write(oprot)
6491 
    oprot.writeMessageEnd()
6492 
    oprot.trans.flush()
6493 
 
6494 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
6495 
    args = sendProductNotifications_args()
6496 
    args.read(iprot)
6497 
    iprot.readMessageEnd()
6498 
    result = sendProductNotifications_result()
6499 
    result.success = self._handler.sendProductNotifications()
6500 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
6501 
    result.write(oprot)
6502 
    oprot.writeMessageEnd()
6503 
    oprot.trans.flush()
6504 
 
6505 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
6506 
    args = getAllBrandsByCategory_args()
6507 
    args.read(iprot)
6508 
    iprot.readMessageEnd()
6509 
    result = getAllBrandsByCategory_result()
6510 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
6511 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
6512 
    result.write(oprot)
6513 
    oprot.writeMessageEnd()
6514 
    oprot.trans.flush()
6515 
 
6516 
  def process_getAllBrands(self, seqid, iprot, oprot):
6517 
    args = getAllBrands_args()
6518 
    args.read(iprot)
6519 
    iprot.readMessageEnd()
6520 
    result = getAllBrands_result()
6521 
    result.success = self._handler.getAllBrands()
6522 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
6523 
    result.write(oprot)
6524 
    oprot.writeMessageEnd()
6525 
    oprot.trans.flush()
6526 
 
6527 
  def process_getAllSources(self, seqid, iprot, oprot):
6528 
    args = getAllSources_args()
6529 
    args.read(iprot)
6530 
    iprot.readMessageEnd()
6531 
    result = getAllSources_result()
6532 
    result.success = self._handler.getAllSources()
6533 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
6534 
    result.write(oprot)
6535 
    oprot.writeMessageEnd()
6536 
    oprot.trans.flush()
6537 
 
6538 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
6539 
    args = getItemPricingBySource_args()
6540 
    args.read(iprot)
6541 
    iprot.readMessageEnd()
6542 
    result = getItemPricingBySource_result()
6543 
    try:
6544 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
6545 
    except CatalogServiceException, cex:
6546 
      result.cex = cex
6547 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
6548 
    result.write(oprot)
6549 
    oprot.writeMessageEnd()
6550 
    oprot.trans.flush()
6551 
 
6552 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
6553 
    args = addSourceItemPricing_args()
6554 
    args.read(iprot)
6555 
    iprot.readMessageEnd()
6556 
    result = addSourceItemPricing_result()
6557 
    try:
6558 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
6559 
    except CatalogServiceException, cex:
6560 
      result.cex = cex
6561 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
6562 
    result.write(oprot)
6563 
    oprot.writeMessageEnd()
6564 
    oprot.trans.flush()
6565 
 
6566 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
6567 
    args = getAllSourcePricing_args()
6568 
    args.read(iprot)
6569 
    iprot.readMessageEnd()
6570 
    result = getAllSourcePricing_result()
6571 
    try:
6572 
      result.success = self._handler.getAllSourcePricing(args.itemId)
6573 
    except CatalogServiceException, cex:
6574 
      result.cex = cex
6575 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
6576 
    result.write(oprot)
6577 
    oprot.writeMessageEnd()
6578 
    oprot.trans.flush()
6579 
 
6580 
  def process_getItemForSource(self, seqid, iprot, oprot):
6581 
    args = getItemForSource_args()
6582 
    args.read(iprot)
6583 
    iprot.readMessageEnd()
6584 
    result = getItemForSource_result()
6585 
    try:
6586 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
6587 
    except CatalogServiceException, cex:
6588 
      result.cex = cex
6589 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
6590 
    result.write(oprot)
6591 
    oprot.writeMessageEnd()
6592 
    oprot.trans.flush()
6593 
 
6594 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
6595 
    args = searchItemsInRange_args()
6596 
    args.read(iprot)
6597 
    iprot.readMessageEnd()
6598 
    result = searchItemsInRange_result()
6599 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
6600 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
6601 
    result.write(oprot)
6602 
    oprot.writeMessageEnd()
6603 
    oprot.trans.flush()
6604 
 
6605 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
6606 
    args = getSearchResultCount_args()
6607 
    args.read(iprot)
6608 
    iprot.readMessageEnd()
6609 
    result = getSearchResultCount_result()
6610 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
6611 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
6612 
    result.write(oprot)
6613 
    oprot.writeMessageEnd()
6614 
    oprot.trans.flush()
6615 
 
6616 
  def process_getProductNotifications(self, seqid, iprot, oprot):
6617 
    args = getProductNotifications_args()
6618 
    args.read(iprot)
6619 
    iprot.readMessageEnd()
6620 
    result = getProductNotifications_result()
6621 
    result.success = self._handler.getProductNotifications(args.startDateTime)
6622 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
6623 
    result.write(oprot)
6624 
    oprot.writeMessageEnd()
6625 
    oprot.trans.flush()
6626 
 
6627 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
6628 
    args = getProductNotificationRequestCount_args()
6629 
    args.read(iprot)
6630 
    iprot.readMessageEnd()
6631 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 6632 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 6633 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
6634 
    result.write(oprot)
6635 
    oprot.writeMessageEnd()
6636 
    oprot.trans.flush()
6637 
 
6638 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
6639 
    args = addAuthorizationLog_args()
6640 
    args.read(iprot)
6641 
    iprot.readMessageEnd()
6642 
    result = addAuthorizationLog_result()
6643 
    try:
6644 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
6645 
    except CatalogServiceException, cex:
6646 
      result.cex = cex
6647 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
6648 
    result.write(oprot)
6649 
    oprot.writeMessageEnd()
6650 
    oprot.trans.flush()
6651 
 
6652 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
6653 
    args = addupdateVoucherForItem_args()
6654 
    args.read(iprot)
6655 
    iprot.readMessageEnd()
6656 
    result = addupdateVoucherForItem_result()
6657 
    try:
6658 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
6659 
    except CatalogServiceException, cex:
6660 
      result.cex = cex
6661 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
6662 
    result.write(oprot)
6663 
    oprot.writeMessageEnd()
6664 
    oprot.trans.flush()
6665 
 
6666 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
6667 
    args = deleteVoucherForItem_args()
6668 
    args.read(iprot)
6669 
    iprot.readMessageEnd()
6670 
    result = deleteVoucherForItem_result()
6671 
    try:
6672 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
6673 
    except CatalogServiceException, cex:
6674 
      result.cex = cex
6675 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
6676 
    result.write(oprot)
6677 
    oprot.writeMessageEnd()
6678 
    oprot.trans.flush()
6679 
 
6680 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
6681 
    args = getVoucherAmount_args()
6682 
    args.read(iprot)
6683 
    iprot.readMessageEnd()
6684 
    result = getVoucherAmount_result()
6685 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
6686 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
6687 
    result.write(oprot)
6688 
    oprot.writeMessageEnd()
6689 
    oprot.trans.flush()
6690 
 
6691 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
6692 
    args = getAllItemVouchers_args()
6693 
    args.read(iprot)
6694 
    iprot.readMessageEnd()
6695 
    result = getAllItemVouchers_result()
6696 
    result.success = self._handler.getAllItemVouchers(args.itemId)
6697 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
6698 
    result.write(oprot)
6699 
    oprot.writeMessageEnd()
6700 
    oprot.trans.flush()
6701 
 
6702 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
6703 
    args = isValidCatalogItemId_args()
6704 
    args.read(iprot)
6705 
    iprot.readMessageEnd()
6706 
    result = isValidCatalogItemId_result()
6707 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
6708 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
6709 
    result.write(oprot)
6710 
    oprot.writeMessageEnd()
6711 
    oprot.trans.flush()
6712 
 
6039 amit.gupta 6713 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
6714 
    args = getVatPercentageForItem_args()
6715 
    args.read(iprot)
6716 
    iprot.readMessageEnd()
6717 
    result = getVatPercentageForItem_result()
7340 amit.gupta 6718 
    try:
6719 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
6720 
    except CatalogServiceException, cex:
6721 
      result.cex = cex
6039 amit.gupta 6722 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
6723 
    result.write(oprot)
6724 
    oprot.writeMessageEnd()
6725 
    oprot.trans.flush()
5944 mandeep.dh 6726 
 
6039 amit.gupta 6727 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
6728 
    args = getVatAmountForItem_args()
6729 
    args.read(iprot)
6730 
    iprot.readMessageEnd()
6731 
    result = getVatAmountForItem_result()
6732 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
6733 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
6734 
    result.write(oprot)
6735 
    oprot.writeMessageEnd()
6736 
    oprot.trans.flush()
6737 
 
6531 vikram.rag 6738 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
6739 
    args = getAllIgnoredInventoryUpdateItemsList_args()
6740 
    args.read(iprot)
6741 
    iprot.readMessageEnd()
6742 
    result = getAllIgnoredInventoryUpdateItemsList_result()
6743 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
6744 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
6745 
    result.write(oprot)
6746 
    oprot.writeMessageEnd()
6747 
    oprot.trans.flush()
6039 amit.gupta 6748 
 
6821 amar.kumar 6749 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
6750 
    args = getAllAliveItems_args()
6751 
    args.read(iprot)
6752 
    iprot.readMessageEnd()
6753 
    result = getAllAliveItems_result()
6754 
    result.success = self._handler.getAllAliveItems()
6755 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
6756 
    result.write(oprot)
6757 
    oprot.writeMessageEnd()
6758 
    oprot.trans.flush()
6759 
 
6805 anupam.sin 6760 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
6761 
    args = getInsuranceAmount_args()
6762 
    args.read(iprot)
6763 
    iprot.readMessageEnd()
6764 
    result = getInsuranceAmount_result()
6921 anupam.sin 6765 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 6766 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
6767 
    result.write(oprot)
6768 
    oprot.writeMessageEnd()
6769 
    oprot.trans.flush()
6531 vikram.rag 6770 
 
6805 anupam.sin 6771 
  def process_getInsurer(self, seqid, iprot, oprot):
6772 
    args = getInsurer_args()
6773 
    args.read(iprot)
6774 
    iprot.readMessageEnd()
6775 
    result = getInsurer_result()
6776 
    result.success = self._handler.getInsurer(args.insurerId)
6777 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
6778 
    result.write(oprot)
6779 
    oprot.writeMessageEnd()
6780 
    oprot.trans.flush()
6781 
 
6838 vikram.rag 6782 
  def process_getAllInsurers(self, seqid, iprot, oprot):
6783 
    args = getAllInsurers_args()
6784 
    args.read(iprot)
6785 
    iprot.readMessageEnd()
6786 
    result = getAllInsurers_result()
6787 
    result.success = self._handler.getAllInsurers()
6788 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
6789 
    result.write(oprot)
6790 
    oprot.writeMessageEnd()
6791 
    oprot.trans.flush()
6805 anupam.sin 6792 
 
6962 rajveer 6793 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
6794 
    args = updateInsuranceDeclaredAmount_args()
6795 
    args.read(iprot)
6796 
    iprot.readMessageEnd()
6797 
    result = updateInsuranceDeclaredAmount_result()
6798 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
6799 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
6800 
    result.write(oprot)
6801 
    oprot.writeMessageEnd()
6802 
    oprot.trans.flush()
6838 vikram.rag 6803 
 
7190 amar.kumar 6804 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
6805 
    args = getFreebieForItem_args()
6806 
    args.read(iprot)
6807 
    iprot.readMessageEnd()
6808 
    result = getFreebieForItem_result()
6809 
    result.success = self._handler.getFreebieForItem(args.itemId)
6810 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
6811 
    result.write(oprot)
6812 
    oprot.writeMessageEnd()
6813 
    oprot.trans.flush()
6962 rajveer 6814 
 
7190 amar.kumar 6815 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
6816 
    args = addOrUpdateFreebieForItem_args()
6817 
    args.read(iprot)
6818 
    iprot.readMessageEnd()
6819 
    result = addOrUpdateFreebieForItem_result()
6820 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
6821 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
6822 
    result.write(oprot)
6823 
    oprot.writeMessageEnd()
6824 
    oprot.trans.flush()
6825 
 
7272 amit.gupta 6826 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
6827 
    args = addOrUpdateBrandInfo_args()
6828 
    args.read(iprot)
6829 
    iprot.readMessageEnd()
6830 
    result = addOrUpdateBrandInfo_result()
6831 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
6832 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
6833 
    result.write(oprot)
6834 
    oprot.writeMessageEnd()
6835 
    oprot.trans.flush()
6836 
 
6837 
  def process_getBrandInfo(self, seqid, iprot, oprot):
6838 
    args = getBrandInfo_args()
6839 
    args.read(iprot)
6840 
    iprot.readMessageEnd()
6841 
    result = getBrandInfo_result()
6842 
    result.success = self._handler.getBrandInfo()
6843 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
6844 
    result.write(oprot)
6845 
    oprot.writeMessageEnd()
6846 
    oprot.trans.flush()
6847 
 
7256 rajveer 6848 
  def process_getStorePricing(self, seqid, iprot, oprot):
6849 
    args = getStorePricing_args()
6850 
    args.read(iprot)
6851 
    iprot.readMessageEnd()
6852 
    result = getStorePricing_result()
6853 
    result.success = self._handler.getStorePricing(args.itemId)
6854 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
6855 
    result.write(oprot)
6856 
    oprot.writeMessageEnd()
6857 
    oprot.trans.flush()
7190 amar.kumar 6858 
 
7306 rajveer 6859 
  def process_getStorePricings(self, seqid, iprot, oprot):
6860 
    args = getStorePricings_args()
6861 
    args.read(iprot)
6862 
    iprot.readMessageEnd()
6863 
    result = getStorePricings_result()
6864 
    result.success = self._handler.getStorePricings(args.itemIds)
6865 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
6866 
    result.write(oprot)
6867 
    oprot.writeMessageEnd()
6868 
    oprot.trans.flush()
6869 
 
7265 rajveer 6870 
  def process_updateStorePricing(self, seqid, iprot, oprot):
6871 
    args = updateStorePricing_args()
6872 
    args.read(iprot)
6873 
    iprot.readMessageEnd()
6874 
    result = updateStorePricing_result()
7382 rajveer 6875 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 6876 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
6877 
    result.write(oprot)
6878 
    oprot.writeMessageEnd()
6879 
    oprot.trans.flush()
7256 rajveer 6880 
 
7281 kshitij.so 6881 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
6882 
    args = getAllAmazonListedItems_args()
6883 
    args.read(iprot)
6884 
    iprot.readMessageEnd()
6885 
    result = getAllAmazonListedItems_result()
6886 
    result.success = self._handler.getAllAmazonListedItems()
6887 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
6888 
    result.write(oprot)
6889 
    oprot.writeMessageEnd()
6890 
    oprot.trans.flush()
7265 rajveer 6891 
 
8619 kshitij.so 6892 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
6893 
    args = searchAmazonItems_args()
6894 
    args.read(iprot)
6895 
    iprot.readMessageEnd()
6896 
    result = searchAmazonItems_result()
6897 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
6898 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
6899 
    result.write(oprot)
6900 
    oprot.writeMessageEnd()
6901 
    oprot.trans.flush()
6902 
 
6903 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
6904 
    args = getAmazonSearchResultCount_args()
6905 
    args.read(iprot)
6906 
    iprot.readMessageEnd()
6907 
    result = getAmazonSearchResultCount_result()
6908 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
6909 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
6910 
    result.write(oprot)
6911 
    oprot.writeMessageEnd()
6912 
    oprot.trans.flush()
6913 
 
6914 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
6915 
    args = getCountForAmazonlistedItems_args()
6916 
    args.read(iprot)
6917 
    iprot.readMessageEnd()
6918 
    result = getCountForAmazonlistedItems_result()
6919 
    result.success = self._handler.getCountForAmazonlistedItems()
6920 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
6921 
    result.write(oprot)
6922 
    oprot.writeMessageEnd()
6923 
    oprot.trans.flush()
6924 
 
7281 kshitij.so 6925 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
6926 
    args = getAmazonItemDetails_args()
6927 
    args.read(iprot)
6928 
    iprot.readMessageEnd()
6929 
    result = getAmazonItemDetails_result()
6930 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
6931 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
6932 
    result.write(oprot)
6933 
    oprot.writeMessageEnd()
6934 
    oprot.trans.flush()
6935 
 
6936 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
6937 
    args = updateAmazonItemDetails_args()
6938 
    args.read(iprot)
6939 
    iprot.readMessageEnd()
6940 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 6941 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 6942 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
6943 
    result.write(oprot)
6944 
    oprot.writeMessageEnd()
6945 
    oprot.trans.flush()
6946 
 
6947 
  def process_addAmazonItem(self, seqid, iprot, oprot):
6948 
    args = addAmazonItem_args()
6949 
    args.read(iprot)
6950 
    iprot.readMessageEnd()
6951 
    result = addAmazonItem_result()
6952 
    self._handler.addAmazonItem(args.amazonlisted)
6953 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
6954 
    result.write(oprot)
6955 
    oprot.writeMessageEnd()
6956 
    oprot.trans.flush()
6957 
 
7291 vikram.rag 6958 
  def process_getAsinItems(self, seqid, iprot, oprot):
6959 
    args = getAsinItems_args()
6960 
    args.read(iprot)
6961 
    iprot.readMessageEnd()
6962 
    result = getAsinItems_result()
6963 
    result.success = self._handler.getAsinItems()
6964 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
6965 
    result.write(oprot)
6966 
    oprot.writeMessageEnd()
6967 
    oprot.trans.flush()
7281 kshitij.so 6968 
 
7291 vikram.rag 6969 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
6970 
    args = getAllFbaListedItems_args()
6971 
    args.read(iprot)
6972 
    iprot.readMessageEnd()
6973 
    result = getAllFbaListedItems_result()
6974 
    result.success = self._handler.getAllFbaListedItems()
6975 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
6976 
    result.write(oprot)
6977 
    oprot.writeMessageEnd()
6978 
    oprot.trans.flush()
6979 
 
6980 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
6981 
    args = getAllNonFbaListedItems_args()
6982 
    args.read(iprot)
6983 
    iprot.readMessageEnd()
6984 
    result = getAllNonFbaListedItems_result()
6985 
    result.success = self._handler.getAllNonFbaListedItems()
6986 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
6987 
    result.write(oprot)
6988 
    oprot.writeMessageEnd()
6989 
    oprot.trans.flush()
6990 
 
7460 kshitij.so 6991 
  def process_updateItemInventory(self, seqid, iprot, oprot):
6992 
    args = updateItemInventory_args()
6993 
    args.read(iprot)
6994 
    iprot.readMessageEnd()
6995 
    result = updateItemInventory_result()
6996 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
6997 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
6998 
    result.write(oprot)
6999 
    oprot.writeMessageEnd()
7000 
    oprot.trans.flush()
7291 vikram.rag 7001 
 
7770 kshitij.so 7002 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
7003 
    args = updateTimestampForAmazonFeeds_args()
7004 
    args.read(iprot)
7005 
    iprot.readMessageEnd()
7006 
    result = updateTimestampForAmazonFeeds_result()
7007 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
7008 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
7009 
    result.write(oprot)
7010 
    oprot.writeMessageEnd()
7011 
    oprot.trans.flush()
7460 kshitij.so 7012 
 
7897 amar.kumar 7013 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
7014 
    args = getAllParentCategories_args()
7015 
    args.read(iprot)
7016 
    iprot.readMessageEnd()
7017 
    result = getAllParentCategories_result()
7018 
    result.success = self._handler.getAllParentCategories()
7019 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
7020 
    result.write(oprot)
7021 
    oprot.writeMessageEnd()
7022 
    oprot.trans.flush()
7770 kshitij.so 7023 
 
7977 kshitij.so 7024 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
7025 
    args = addPageViewEvent_args()
7026 
    args.read(iprot)
7027 
    iprot.readMessageEnd()
7028 
    result = addPageViewEvent_result()
7029 
    self._handler.addPageViewEvent(args.pageViewEvents)
7030 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
7031 
    result.write(oprot)
7032 
    oprot.writeMessageEnd()
7033 
    oprot.trans.flush()
7897 amar.kumar 7034 
 
7977 kshitij.so 7035 
  def process_addCartEvent(self, seqid, iprot, oprot):
7036 
    args = addCartEvent_args()
7037 
    args.read(iprot)
7038 
    iprot.readMessageEnd()
7039 
    result = addCartEvent_result()
7040 
    self._handler.addCartEvent(args.cartEvents)
7041 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
7042 
    result.write(oprot)
7043 
    oprot.writeMessageEnd()
7044 
    oprot.trans.flush()
7045 
 
8182 amar.kumar 7046 
  def process_addEbayItem(self, seqid, iprot, oprot):
7047 
    args = addEbayItem_args()
7048 
    args.read(iprot)
7049 
    iprot.readMessageEnd()
7050 
    result = addEbayItem_result()
7051 
    self._handler.addEbayItem(args.ebayItem)
7052 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
7053 
    result.write(oprot)
7054 
    oprot.writeMessageEnd()
7055 
    oprot.trans.flush()
7056 
 
7057 
  def process_getEbayItem(self, seqid, iprot, oprot):
7058 
    args = getEbayItem_args()
7059 
    args.read(iprot)
7060 
    iprot.readMessageEnd()
7061 
    result = getEbayItem_result()
7062 
    result.success = self._handler.getEbayItem(args.listingId)
7063 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
7064 
    result.write(oprot)
7065 
    oprot.writeMessageEnd()
7066 
    oprot.trans.flush()
7067 
 
7068 
  def process_updateEbayItem(self, seqid, iprot, oprot):
7069 
    args = updateEbayItem_args()
7070 
    args.read(iprot)
7071 
    iprot.readMessageEnd()
7072 
    result = updateEbayItem_result()
7073 
    self._handler.updateEbayItem(args.ebayItem)
7074 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
7075 
    result.write(oprot)
7076 
    oprot.writeMessageEnd()
7077 
    oprot.trans.flush()
7078 
 
8139 kshitij.so 7079 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
7080 
    args = getAmazonListedItems_args()
7081 
    args.read(iprot)
7082 
    iprot.readMessageEnd()
7083 
    result = getAmazonListedItems_result()
7084 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
7085 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
7086 
    result.write(oprot)
7087 
    oprot.writeMessageEnd()
7088 
    oprot.trans.flush()
7977 kshitij.so 7089 
 
8168 kshitij.so 7090 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
7091 
    args = updateAmazonAttributesInBulk_args()
7092 
    args.read(iprot)
7093 
    iprot.readMessageEnd()
7094 
    result = updateAmazonAttributesInBulk_result()
7095 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
7096 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
7097 
    result.write(oprot)
7098 
    oprot.writeMessageEnd()
7099 
    oprot.trans.flush()
8139 kshitij.so 7100 
 
8379 vikram.rag 7101 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
7102 
    args = getAllItemstoListOnFba_args()
7103 
    args.read(iprot)
7104 
    iprot.readMessageEnd()
7105 
    result = getAllItemstoListOnFba_result()
7106 
    result.success = self._handler.getAllItemstoListOnFba()
7107 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
7108 
    result.write(oprot)
7109 
    oprot.writeMessageEnd()
7110 
    oprot.trans.flush()
8168 kshitij.so 7111 
 
8379 vikram.rag 7112 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
7113 
    args = getAllItemstoListOnNonFba_args()
7114 
    args.read(iprot)
7115 
    iprot.readMessageEnd()
7116 
    result = getAllItemstoListOnNonFba_result()
7117 
    result.success = self._handler.getAllItemstoListOnNonFba()
7118 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
7119 
    result.write(oprot)
7120 
    oprot.writeMessageEnd()
7121 
    oprot.trans.flush()
7122 
 
8619 kshitij.so 7123 
  def process_updateAsin(self, seqid, iprot, oprot):
7124 
    args = updateAsin_args()
7125 
    args.read(iprot)
7126 
    iprot.readMessageEnd()
7127 
    result = updateAsin_result()
7128 
    self._handler.updateAsin(args.item)
7129 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
7130 
    result.write(oprot)
7131 
    oprot.writeMessageEnd()
7132 
    oprot.trans.flush()
8616 vikram.rag 7133 
 
8739 vikram.rag 7134 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
7135 
    args = addOrUpdateSnapdealItem_args()
7136 
    args.read(iprot)
7137 
    iprot.readMessageEnd()
7138 
    result = addOrUpdateSnapdealItem_result()
7139 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
7140 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
7141 
    result.write(oprot)
7142 
    oprot.writeMessageEnd()
7143 
    oprot.trans.flush()
8619 kshitij.so 7144 
 
8739 vikram.rag 7145 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
7146 
    args = getSnapdealItem_args()
7147 
    args.read(iprot)
7148 
    iprot.readMessageEnd()
7149 
    result = getSnapdealItem_result()
7150 
    result.success = self._handler.getSnapdealItem(args.item_id)
7151 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
7152 
    result.write(oprot)
7153 
    oprot.writeMessageEnd()
7154 
    oprot.trans.flush()
7155 
 
9242 kshitij.so 7156 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
7157 
    args = getSnapdealItemDetails_args()
7158 
    args.read(iprot)
7159 
    iprot.readMessageEnd()
7160 
    result = getSnapdealItemDetails_result()
7161 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
7162 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
7163 
    result.write(oprot)
7164 
    oprot.writeMessageEnd()
7165 
    oprot.trans.flush()
7166 
 
8739 vikram.rag 7167 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
7168 
    args = getAllSnapdealItems_args()
7169 
    args.read(iprot)
7170 
    iprot.readMessageEnd()
7171 
    result = getAllSnapdealItems_result()
7172 
    result.success = self._handler.getAllSnapdealItems()
7173 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
7174 
    result.write(oprot)
7175 
    oprot.writeMessageEnd()
7176 
    oprot.trans.flush()
7177 
 
9242 kshitij.so 7178 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
7179 
    args = getSnapdealItems_args()
7180 
    args.read(iprot)
7181 
    iprot.readMessageEnd()
7182 
    result = getSnapdealItems_result()
7183 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
7184 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
7185 
    result.write(oprot)
7186 
    oprot.writeMessageEnd()
7187 
    oprot.trans.flush()
8739 vikram.rag 7188 
 
9242 kshitij.so 7189 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
7190 
    args = searchSnapdealItems_args()
7191 
    args.read(iprot)
7192 
    iprot.readMessageEnd()
7193 
    result = searchSnapdealItems_result()
7194 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
7195 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
7196 
    result.write(oprot)
7197 
    oprot.writeMessageEnd()
7198 
    oprot.trans.flush()
7199 
 
7200 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
7201 
    args = getCountForSnapdealItems_args()
7202 
    args.read(iprot)
7203 
    iprot.readMessageEnd()
7204 
    result = getCountForSnapdealItems_result()
7205 
    result.success = self._handler.getCountForSnapdealItems()
7206 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
7207 
    result.write(oprot)
7208 
    oprot.writeMessageEnd()
7209 
    oprot.trans.flush()
7210 
 
7211 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
7212 
    args = getSnapdealSearchResultCount_args()
7213 
    args.read(iprot)
7214 
    iprot.readMessageEnd()
7215 
    result = getSnapdealSearchResultCount_result()
7216 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
7217 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
7218 
    result.write(oprot)
7219 
    oprot.writeMessageEnd()
7220 
    oprot.trans.flush()
7221 
 
9299 kshitij.so 7222 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
7223 
    args = getPrefferedInsurerForItem_args()
7224 
    args.read(iprot)
7225 
    iprot.readMessageEnd()
7226 
    result = getPrefferedInsurerForItem_result()
7227 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
7228 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
7229 
    result.write(oprot)
7230 
    oprot.writeMessageEnd()
7231 
    oprot.trans.flush()
9242 kshitij.so 7232 
 
9456 vikram.rag 7233 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
7234 
    args = getSnapdealItembySkuAtSnapdeal_args()
7235 
    args.read(iprot)
7236 
    iprot.readMessageEnd()
7237 
    result = getSnapdealItembySkuAtSnapdeal_result()
7238 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
7239 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
7240 
    result.write(oprot)
7241 
    oprot.writeMessageEnd()
7242 
    oprot.trans.flush()
9299 kshitij.so 7243 
 
9621 manish.sha 7244 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
7245 
    args = getProductFeedSubmit_args()
7246 
    args.read(iprot)
7247 
    iprot.readMessageEnd()
7248 
    result = getProductFeedSubmit_result()
7249 
    try:
7250 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
7251 
    except CatalogServiceException, cex:
7252 
      result.cex = cex
7253 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
7254 
    result.write(oprot)
7255 
    oprot.writeMessageEnd()
7256 
    oprot.trans.flush()
9456 vikram.rag 7257 
 
9621 manish.sha 7258 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
7259 
    args = addProductFeedSubmit_args()
7260 
    args.read(iprot)
7261 
    iprot.readMessageEnd()
7262 
    result = addProductFeedSubmit_result()
7263 
    try:
7264 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
7265 
    except CatalogServiceException, cex:
7266 
      result.cex = cex
7267 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
7268 
    result.write(oprot)
7269 
    oprot.writeMessageEnd()
7270 
    oprot.trans.flush()
7271 
 
7272 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
7273 
    args = updateProductFeedSubmit_args()
7274 
    args.read(iprot)
7275 
    iprot.readMessageEnd()
7276 
    result = updateProductFeedSubmit_result()
7277 
    try:
7278 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
7279 
    except CatalogServiceException, cex:
7280 
      result.cex = cex
7281 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
7282 
    result.write(oprot)
7283 
    oprot.writeMessageEnd()
7284 
    oprot.trans.flush()
7285 
 
7286 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
7287 
    args = deleteProductFeedSubmit_args()
7288 
    args.read(iprot)
7289 
    iprot.readMessageEnd()
7290 
    result = deleteProductFeedSubmit_result()
7291 
    try:
7292 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
7293 
    except CatalogServiceException, cex:
7294 
      result.cex = cex
7295 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
7296 
    result.write(oprot)
7297 
    oprot.writeMessageEnd()
7298 
    oprot.trans.flush()
7299 
 
7300 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
7301 
    args = getAllProductFeedSubmit_args()
7302 
    args.read(iprot)
7303 
    iprot.readMessageEnd()
7304 
    result = getAllProductFeedSubmit_result()
7305 
    try:
7306 
      result.success = self._handler.getAllProductFeedSubmit()
7307 
    except CatalogServiceException, cex:
7308 
      result.cex = cex
7309 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
7310 
    result.write(oprot)
7311 
    oprot.writeMessageEnd()
7312 
    oprot.trans.flush()
7313 
 
9724 kshitij.so 7314 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
7315 
    args = getMarketplacedetailsForItem_args()
7316 
    args.read(iprot)
7317 
    iprot.readMessageEnd()
7318 
    result = getMarketplacedetailsForItem_result()
7319 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
7320 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
7321 
    result.write(oprot)
7322 
    oprot.writeMessageEnd()
7323 
    oprot.trans.flush()
9621 manish.sha 7324 
 
9724 kshitij.so 7325 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
7326 
    args = updateMarketplaceAttributesForItem_args()
7327 
    args.read(iprot)
7328 
    iprot.readMessageEnd()
7329 
    result = updateMarketplaceAttributesForItem_result()
7330 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
7331 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
7332 
    result.write(oprot)
7333 
    oprot.writeMessageEnd()
7334 
    oprot.trans.flush()
7335 
 
9779 kshitij.so 7336 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
7337 
    args = getCostingForMarketplace_args()
7338 
    args.read(iprot)
7339 
    iprot.readMessageEnd()
7340 
    result = getCostingForMarketplace_result()
7341 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
7342 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
7343 
    result.write(oprot)
7344 
    oprot.writeMessageEnd()
7345 
    oprot.trans.flush()
7346 
 
9776 vikram.rag 7347 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
7348 
    args = getMarketPlaceItemsForPriceUpdate_args()
7349 
    args.read(iprot)
7350 
    iprot.readMessageEnd()
7351 
    result = getMarketPlaceItemsForPriceUpdate_result()
7352 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
7353 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
7354 
    result.write(oprot)
7355 
    oprot.writeMessageEnd()
7356 
    oprot.trans.flush()
9724 kshitij.so 7357 
 
9776 vikram.rag 7358 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
7359 
    args = updateMarketPlacePriceUpdateStatus_args()
7360 
    args.read(iprot)
7361 
    iprot.readMessageEnd()
7362 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 7363 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 7364 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
7365 
    result.write(oprot)
7366 
    oprot.writeMessageEnd()
7367 
    oprot.trans.flush()
7368 
 
9861 rajveer 7369 
  def process_updateItemHoldInventory(self, seqid, iprot, oprot):
7370 
    args = updateItemHoldInventory_args()
7371 
    args.read(iprot)
7372 
    iprot.readMessageEnd()
7373 
    result = updateItemHoldInventory_result()
7374 
    self._handler.updateItemHoldInventory(args.itemHoldMap)
7375 
    oprot.writeMessageBegin("updateItemHoldInventory", TMessageType.REPLY, seqid)
7376 
    result.write(oprot)
7377 
    oprot.writeMessageEnd()
7378 
    oprot.trans.flush()
9776 vikram.rag 7379 
 
9895 vikram.rag 7380 
  def process_updateNlcAtMarketplaces(self, seqid, iprot, oprot):
7381 
    args = updateNlcAtMarketplaces_args()
7382 
    args.read(iprot)
7383 
    iprot.readMessageEnd()
7384 
    result = updateNlcAtMarketplaces_result()
7385 
    self._handler.updateNlcAtMarketplaces(args.item_id, args.vendor_id, args.nlc)
7386 
    oprot.writeMessageBegin("updateNlcAtMarketplaces", TMessageType.REPLY, seqid)
7387 
    result.write(oprot)
7388 
    oprot.writeMessageEnd()
7389 
    oprot.trans.flush()
9861 rajveer 7390 
 
9945 vikram.rag 7391 
  def process_getAllFlipkartItems(self, seqid, iprot, oprot):
7392 
    args = getAllFlipkartItems_args()
7393 
    args.read(iprot)
7394 
    iprot.readMessageEnd()
7395 
    result = getAllFlipkartItems_result()
7396 
    result.success = self._handler.getAllFlipkartItems()
7397 
    oprot.writeMessageBegin("getAllFlipkartItems", TMessageType.REPLY, seqid)
7398 
    result.write(oprot)
7399 
    oprot.writeMessageEnd()
7400 
    oprot.trans.flush()
9895 vikram.rag 7401 
 
9945 vikram.rag 7402 
 
5944 mandeep.dh 7403 
# HELPER FUNCTIONS AND STRUCTURES
7404 
 
7405 
class addItem_args:
7406 
  """
7407 
  Attributes:
7408 
   - item
7409 
  """
7410 
 
7411 
  thrift_spec = (
7412 
    None, # 0
7413 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7414 
  )
7415 
 
7416 
  def __init__(self, item=None,):
7417 
    self.item = item
7418 
 
7419 
  def read(self, iprot):
7420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7422 
      return
7423 
    iprot.readStructBegin()
7424 
    while True:
7425 
      (fname, ftype, fid) = iprot.readFieldBegin()
7426 
      if ftype == TType.STOP:
7427 
        break
7428 
      if fid == 1:
7429 
        if ftype == TType.STRUCT:
7430 
          self.item = Item()
7431 
          self.item.read(iprot)
7432 
        else:
7433 
          iprot.skip(ftype)
7434 
      else:
7435 
        iprot.skip(ftype)
7436 
      iprot.readFieldEnd()
7437 
    iprot.readStructEnd()
7438 
 
7439 
  def write(self, oprot):
7440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7442 
      return
7443 
    oprot.writeStructBegin('addItem_args')
7444 
    if self.item is not None:
7445 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7446 
      self.item.write(oprot)
7447 
      oprot.writeFieldEnd()
7448 
    oprot.writeFieldStop()
7449 
    oprot.writeStructEnd()
7450 
 
7451 
  def validate(self):
7452 
    return
7453 
 
7454 
 
7455 
  def __repr__(self):
7456 
    L = ['%s=%r' % (key, value)
7457 
      for key, value in self.__dict__.iteritems()]
7458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7459 
 
7460 
  def __eq__(self, other):
7461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7462 
 
7463 
  def __ne__(self, other):
7464 
    return not (self == other)
7465 
 
7466 
class addItem_result:
7467 
  """
7468 
  Attributes:
7469 
   - success
7470 
   - cex
7471 
  """
7472 
 
7473 
  thrift_spec = (
7474 
    (0, TType.I64, 'success', None, None, ), # 0
7475 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7476 
  )
7477 
 
7478 
  def __init__(self, success=None, cex=None,):
7479 
    self.success = success
7480 
    self.cex = cex
7481 
 
7482 
  def read(self, iprot):
7483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7485 
      return
7486 
    iprot.readStructBegin()
7487 
    while True:
7488 
      (fname, ftype, fid) = iprot.readFieldBegin()
7489 
      if ftype == TType.STOP:
7490 
        break
7491 
      if fid == 0:
7492 
        if ftype == TType.I64:
7493 
          self.success = iprot.readI64();
7494 
        else:
7495 
          iprot.skip(ftype)
7496 
      elif fid == 1:
7497 
        if ftype == TType.STRUCT:
7498 
          self.cex = CatalogServiceException()
7499 
          self.cex.read(iprot)
7500 
        else:
7501 
          iprot.skip(ftype)
7502 
      else:
7503 
        iprot.skip(ftype)
7504 
      iprot.readFieldEnd()
7505 
    iprot.readStructEnd()
7506 
 
7507 
  def write(self, oprot):
7508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7510 
      return
7511 
    oprot.writeStructBegin('addItem_result')
7512 
    if self.success is not None:
7513 
      oprot.writeFieldBegin('success', TType.I64, 0)
7514 
      oprot.writeI64(self.success)
7515 
      oprot.writeFieldEnd()
7516 
    if self.cex is not None:
7517 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7518 
      self.cex.write(oprot)
7519 
      oprot.writeFieldEnd()
7520 
    oprot.writeFieldStop()
7521 
    oprot.writeStructEnd()
7522 
 
7523 
  def validate(self):
7524 
    return
7525 
 
7526 
 
7527 
  def __repr__(self):
7528 
    L = ['%s=%r' % (key, value)
7529 
      for key, value in self.__dict__.iteritems()]
7530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7531 
 
7532 
  def __eq__(self, other):
7533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7534 
 
7535 
  def __ne__(self, other):
7536 
    return not (self == other)
7537 
 
7538 
class updateItem_args:
7539 
  """
7540 
  Attributes:
7541 
   - item
7542 
  """
7543 
 
7544 
  thrift_spec = (
7545 
    None, # 0
7546 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7547 
  )
7548 
 
7549 
  def __init__(self, item=None,):
7550 
    self.item = item
7551 
 
7552 
  def read(self, iprot):
7553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7555 
      return
7556 
    iprot.readStructBegin()
7557 
    while True:
7558 
      (fname, ftype, fid) = iprot.readFieldBegin()
7559 
      if ftype == TType.STOP:
7560 
        break
7561 
      if fid == 1:
7562 
        if ftype == TType.STRUCT:
7563 
          self.item = Item()
7564 
          self.item.read(iprot)
7565 
        else:
7566 
          iprot.skip(ftype)
7567 
      else:
7568 
        iprot.skip(ftype)
7569 
      iprot.readFieldEnd()
7570 
    iprot.readStructEnd()
7571 
 
7572 
  def write(self, oprot):
7573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7575 
      return
7576 
    oprot.writeStructBegin('updateItem_args')
7577 
    if self.item is not None:
7578 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7579 
      self.item.write(oprot)
7580 
      oprot.writeFieldEnd()
7581 
    oprot.writeFieldStop()
7582 
    oprot.writeStructEnd()
7583 
 
7584 
  def validate(self):
7585 
    return
7586 
 
7587 
 
7588 
  def __repr__(self):
7589 
    L = ['%s=%r' % (key, value)
7590 
      for key, value in self.__dict__.iteritems()]
7591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7592 
 
7593 
  def __eq__(self, other):
7594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7595 
 
7596 
  def __ne__(self, other):
7597 
    return not (self == other)
7598 
 
7599 
class updateItem_result:
7600 
  """
7601 
  Attributes:
7602 
   - success
7603 
   - cex
7604 
  """
7605 
 
7606 
  thrift_spec = (
7607 
    (0, TType.I64, 'success', None, None, ), # 0
7608 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7609 
  )
7610 
 
7611 
  def __init__(self, success=None, cex=None,):
7612 
    self.success = success
7613 
    self.cex = cex
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 == 0:
7625 
        if ftype == TType.I64:
7626 
          self.success = iprot.readI64();
7627 
        else:
7628 
          iprot.skip(ftype)
7629 
      elif fid == 1:
7630 
        if ftype == TType.STRUCT:
7631 
          self.cex = CatalogServiceException()
7632 
          self.cex.read(iprot)
7633 
        else:
7634 
          iprot.skip(ftype)
7635 
      else:
7636 
        iprot.skip(ftype)
7637 
      iprot.readFieldEnd()
7638 
    iprot.readStructEnd()
7639 
 
7640 
  def write(self, oprot):
7641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7643 
      return
7644 
    oprot.writeStructBegin('updateItem_result')
7645 
    if self.success is not None:
7646 
      oprot.writeFieldBegin('success', TType.I64, 0)
7647 
      oprot.writeI64(self.success)
7648 
      oprot.writeFieldEnd()
7649 
    if self.cex is not None:
7650 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7651 
      self.cex.write(oprot)
7652 
      oprot.writeFieldEnd()
7653 
    oprot.writeFieldStop()
7654 
    oprot.writeStructEnd()
7655 
 
7656 
  def validate(self):
7657 
    return
7658 
 
7659 
 
7660 
  def __repr__(self):
7661 
    L = ['%s=%r' % (key, value)
7662 
      for key, value in self.__dict__.iteritems()]
7663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7664 
 
7665 
  def __eq__(self, other):
7666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7667 
 
7668 
  def __ne__(self, other):
7669 
    return not (self == other)
7670 
 
7671 
class isActive_args:
7672 
  """
7673 
  Attributes:
7674 
   - itemId
7675 
  """
7676 
 
7677 
  thrift_spec = (
7678 
    None, # 0
7679 
    (1, TType.I64, 'itemId', None, None, ), # 1
7680 
  )
7681 
 
7682 
  def __init__(self, itemId=None,):
7683 
    self.itemId = itemId
7684 
 
7685 
  def read(self, iprot):
7686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7688 
      return
7689 
    iprot.readStructBegin()
7690 
    while True:
7691 
      (fname, ftype, fid) = iprot.readFieldBegin()
7692 
      if ftype == TType.STOP:
7693 
        break
7694 
      if fid == 1:
7695 
        if ftype == TType.I64:
7696 
          self.itemId = iprot.readI64();
7697 
        else:
7698 
          iprot.skip(ftype)
7699 
      else:
7700 
        iprot.skip(ftype)
7701 
      iprot.readFieldEnd()
7702 
    iprot.readStructEnd()
7703 
 
7704 
  def write(self, oprot):
7705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7707 
      return
7708 
    oprot.writeStructBegin('isActive_args')
7709 
    if self.itemId is not None:
7710 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7711 
      oprot.writeI64(self.itemId)
7712 
      oprot.writeFieldEnd()
7713 
    oprot.writeFieldStop()
7714 
    oprot.writeStructEnd()
7715 
 
7716 
  def validate(self):
7717 
    return
7718 
 
7719 
 
7720 
  def __repr__(self):
7721 
    L = ['%s=%r' % (key, value)
7722 
      for key, value in self.__dict__.iteritems()]
7723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7724 
 
7725 
  def __eq__(self, other):
7726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7727 
 
7728 
  def __ne__(self, other):
7729 
    return not (self == other)
7730 
 
7731 
class isActive_result:
7732 
  """
7733 
  Attributes:
7734 
   - success
7735 
   - isex
7736 
  """
7737 
 
7738 
  thrift_spec = (
7739 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
7740 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7741 
  )
7742 
 
7743 
  def __init__(self, success=None, isex=None,):
7744 
    self.success = success
7745 
    self.isex = isex
7746 
 
7747 
  def read(self, iprot):
7748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7750 
      return
7751 
    iprot.readStructBegin()
7752 
    while True:
7753 
      (fname, ftype, fid) = iprot.readFieldBegin()
7754 
      if ftype == TType.STOP:
7755 
        break
7756 
      if fid == 0:
7757 
        if ftype == TType.STRUCT:
7758 
          self.success = ItemShippingInfo()
7759 
          self.success.read(iprot)
7760 
        else:
7761 
          iprot.skip(ftype)
7762 
      elif fid == 1:
7763 
        if ftype == TType.STRUCT:
7764 
          self.isex = CatalogServiceException()
7765 
          self.isex.read(iprot)
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('isActive_result')
7778 
    if self.success is not None:
7779 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7780 
      self.success.write(oprot)
7781 
      oprot.writeFieldEnd()
7782 
    if self.isex is not None:
7783 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7784 
      self.isex.write(oprot)
7785 
      oprot.writeFieldEnd()
7786 
    oprot.writeFieldStop()
7787 
    oprot.writeStructEnd()
7788 
 
7789 
  def validate(self):
7790 
    return
7791 
 
7792 
 
7793 
  def __repr__(self):
7794 
    L = ['%s=%r' % (key, value)
7795 
      for key, value in self.__dict__.iteritems()]
7796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7797 
 
7798 
  def __eq__(self, other):
7799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7800 
 
7801 
  def __ne__(self, other):
7802 
    return not (self == other)
7803 
 
7438 amit.gupta 7804 
class getItemsStatus_args:
7805 
  """
7806 
  Attributes:
7807 
   - itemIds
7808 
  """
7809 
 
7810 
  thrift_spec = (
7811 
    None, # 0
7812 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
7813 
  )
7814 
 
7815 
  def __init__(self, itemIds=None,):
7816 
    self.itemIds = itemIds
7817 
 
7818 
  def read(self, iprot):
7819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7821 
      return
7822 
    iprot.readStructBegin()
7823 
    while True:
7824 
      (fname, ftype, fid) = iprot.readFieldBegin()
7825 
      if ftype == TType.STOP:
7826 
        break
7827 
      if fid == 1:
7828 
        if ftype == TType.LIST:
7829 
          self.itemIds = []
8590 kshitij.so 7830 
          (_etype33, _size30) = iprot.readListBegin()
7831 
          for _i34 in xrange(_size30):
7832 
            _elem35 = iprot.readI64();
7833 
            self.itemIds.append(_elem35)
7438 amit.gupta 7834 
          iprot.readListEnd()
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('getItemsStatus_args')
7847 
    if self.itemIds is not None:
7848 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
7849 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 7850 
      for iter36 in self.itemIds:
7851 
        oprot.writeI64(iter36)
7438 amit.gupta 7852 
      oprot.writeListEnd()
7853 
      oprot.writeFieldEnd()
7854 
    oprot.writeFieldStop()
7855 
    oprot.writeStructEnd()
7856 
 
7857 
  def validate(self):
7858 
    return
7859 
 
7860 
 
7861 
  def __repr__(self):
7862 
    L = ['%s=%r' % (key, value)
7863 
      for key, value in self.__dict__.iteritems()]
7864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7865 
 
7866 
  def __eq__(self, other):
7867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7868 
 
7869 
  def __ne__(self, other):
7870 
    return not (self == other)
7871 
 
7872 
class getItemsStatus_result:
7873 
  """
7874 
  Attributes:
7875 
   - success
7876 
   - isex
7877 
  """
7878 
 
7879 
  thrift_spec = (
7880 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
7881 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7882 
  )
7883 
 
7884 
  def __init__(self, success=None, isex=None,):
7885 
    self.success = success
7886 
    self.isex = isex
7887 
 
7888 
  def read(self, iprot):
7889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7891 
      return
7892 
    iprot.readStructBegin()
7893 
    while True:
7894 
      (fname, ftype, fid) = iprot.readFieldBegin()
7895 
      if ftype == TType.STOP:
7896 
        break
7897 
      if fid == 0:
7898 
        if ftype == TType.MAP:
7899 
          self.success = {}
8590 kshitij.so 7900 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
7901 
          for _i41 in xrange(_size37):
7902 
            _key42 = iprot.readI64();
7903 
            _val43 = iprot.readBool();
7904 
            self.success[_key42] = _val43
7438 amit.gupta 7905 
          iprot.readMapEnd()
7906 
        else:
7907 
          iprot.skip(ftype)
7908 
      elif fid == 1:
7909 
        if ftype == TType.STRUCT:
7910 
          self.isex = CatalogServiceException()
7911 
          self.isex.read(iprot)
7912 
        else:
7913 
          iprot.skip(ftype)
7914 
      else:
7915 
        iprot.skip(ftype)
7916 
      iprot.readFieldEnd()
7917 
    iprot.readStructEnd()
7918 
 
7919 
  def write(self, oprot):
7920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7922 
      return
7923 
    oprot.writeStructBegin('getItemsStatus_result')
7924 
    if self.success is not None:
7925 
      oprot.writeFieldBegin('success', TType.MAP, 0)
7926 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 7927 
      for kiter44,viter45 in self.success.items():
7928 
        oprot.writeI64(kiter44)
7929 
        oprot.writeBool(viter45)
7438 amit.gupta 7930 
      oprot.writeMapEnd()
7931 
      oprot.writeFieldEnd()
7932 
    if self.isex is not None:
7933 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7934 
      self.isex.write(oprot)
7935 
      oprot.writeFieldEnd()
7936 
    oprot.writeFieldStop()
7937 
    oprot.writeStructEnd()
7938 
 
7939 
  def validate(self):
7940 
    return
7941 
 
7942 
 
7943 
  def __repr__(self):
7944 
    L = ['%s=%r' % (key, value)
7945 
      for key, value in self.__dict__.iteritems()]
7946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7947 
 
7948 
  def __eq__(self, other):
7949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7950 
 
7951 
  def __ne__(self, other):
7952 
    return not (self == other)
7953 
 
5944 mandeep.dh 7954 
class getItemStatusDescription_args:
7955 
  """
7956 
  Attributes:
7957 
   - itemId
7958 
  """
7959 
 
7960 
  thrift_spec = (
7961 
    None, # 0
7962 
    (1, TType.I64, 'itemId', None, None, ), # 1
7963 
  )
7964 
 
7965 
  def __init__(self, itemId=None,):
7966 
    self.itemId = itemId
7967 
 
7968 
  def read(self, iprot):
7969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7971 
      return
7972 
    iprot.readStructBegin()
7973 
    while True:
7974 
      (fname, ftype, fid) = iprot.readFieldBegin()
7975 
      if ftype == TType.STOP:
7976 
        break
7977 
      if fid == 1:
7978 
        if ftype == TType.I64:
7979 
          self.itemId = iprot.readI64();
7980 
        else:
7981 
          iprot.skip(ftype)
7982 
      else:
7983 
        iprot.skip(ftype)
7984 
      iprot.readFieldEnd()
7985 
    iprot.readStructEnd()
7986 
 
7987 
  def write(self, oprot):
7988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7990 
      return
7991 
    oprot.writeStructBegin('getItemStatusDescription_args')
7992 
    if self.itemId is not None:
7993 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7994 
      oprot.writeI64(self.itemId)
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 getItemStatusDescription_result:
8015 
  """
8016 
  Attributes:
8017 
   - success
8018 
   - isex
8019 
  """
8020 
 
8021 
  thrift_spec = (
8022 
    (0, TType.STRING, 'success', None, None, ), # 0
8023 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8024 
  )
8025 
 
8026 
  def __init__(self, success=None, isex=None,):
8027 
    self.success = success
8028 
    self.isex = isex
8029 
 
8030 
  def read(self, iprot):
8031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8033 
      return
8034 
    iprot.readStructBegin()
8035 
    while True:
8036 
      (fname, ftype, fid) = iprot.readFieldBegin()
8037 
      if ftype == TType.STOP:
8038 
        break
8039 
      if fid == 0:
8040 
        if ftype == TType.STRING:
8041 
          self.success = iprot.readString();
8042 
        else:
8043 
          iprot.skip(ftype)
8044 
      elif fid == 1:
8045 
        if ftype == TType.STRUCT:
8046 
          self.isex = CatalogServiceException()
8047 
          self.isex.read(iprot)
8048 
        else:
8049 
          iprot.skip(ftype)
8050 
      else:
8051 
        iprot.skip(ftype)
8052 
      iprot.readFieldEnd()
8053 
    iprot.readStructEnd()
8054 
 
8055 
  def write(self, oprot):
8056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8058 
      return
8059 
    oprot.writeStructBegin('getItemStatusDescription_result')
8060 
    if self.success is not None:
8061 
      oprot.writeFieldBegin('success', TType.STRING, 0)
8062 
      oprot.writeString(self.success)
8063 
      oprot.writeFieldEnd()
8064 
    if self.isex is not None:
8065 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8066 
      self.isex.write(oprot)
8067 
      oprot.writeFieldEnd()
8068 
    oprot.writeFieldStop()
8069 
    oprot.writeStructEnd()
8070 
 
8071 
  def validate(self):
8072 
    return
8073 
 
8074 
 
8075 
  def __repr__(self):
8076 
    L = ['%s=%r' % (key, value)
8077 
      for key, value in self.__dict__.iteritems()]
8078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8079 
 
8080 
  def __eq__(self, other):
8081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8082 
 
8083 
  def __ne__(self, other):
8084 
    return not (self == other)
8085 
 
8086 
class startItemOn_args:
8087 
  """
8088 
  Attributes:
8089 
   - item_id
8090 
   - timestamp
8091 
  """
8092 
 
8093 
  thrift_spec = (
8094 
    None, # 0
8095 
    (1, TType.I64, 'item_id', None, None, ), # 1
8096 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8097 
  )
8098 
 
8099 
  def __init__(self, item_id=None, timestamp=None,):
8100 
    self.item_id = item_id
8101 
    self.timestamp = timestamp
8102 
 
8103 
  def read(self, iprot):
8104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8106 
      return
8107 
    iprot.readStructBegin()
8108 
    while True:
8109 
      (fname, ftype, fid) = iprot.readFieldBegin()
8110 
      if ftype == TType.STOP:
8111 
        break
8112 
      if fid == 1:
8113 
        if ftype == TType.I64:
8114 
          self.item_id = iprot.readI64();
8115 
        else:
8116 
          iprot.skip(ftype)
8117 
      elif fid == 2:
8118 
        if ftype == TType.I64:
8119 
          self.timestamp = iprot.readI64();
8120 
        else:
8121 
          iprot.skip(ftype)
8122 
      else:
8123 
        iprot.skip(ftype)
8124 
      iprot.readFieldEnd()
8125 
    iprot.readStructEnd()
8126 
 
8127 
  def write(self, oprot):
8128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8130 
      return
8131 
    oprot.writeStructBegin('startItemOn_args')
8132 
    if self.item_id is not None:
8133 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8134 
      oprot.writeI64(self.item_id)
8135 
      oprot.writeFieldEnd()
8136 
    if self.timestamp is not None:
8137 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8138 
      oprot.writeI64(self.timestamp)
8139 
      oprot.writeFieldEnd()
8140 
    oprot.writeFieldStop()
8141 
    oprot.writeStructEnd()
8142 
 
8143 
  def validate(self):
8144 
    return
8145 
 
8146 
 
8147 
  def __repr__(self):
8148 
    L = ['%s=%r' % (key, value)
8149 
      for key, value in self.__dict__.iteritems()]
8150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8151 
 
8152 
  def __eq__(self, other):
8153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8154 
 
8155 
  def __ne__(self, other):
8156 
    return not (self == other)
8157 
 
8158 
class startItemOn_result:
8159 
  """
8160 
  Attributes:
8161 
   - cex
8162 
  """
8163 
 
8164 
  thrift_spec = (
8165 
    None, # 0
8166 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8167 
  )
8168 
 
8169 
  def __init__(self, cex=None,):
8170 
    self.cex = cex
8171 
 
8172 
  def read(self, iprot):
8173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8175 
      return
8176 
    iprot.readStructBegin()
8177 
    while True:
8178 
      (fname, ftype, fid) = iprot.readFieldBegin()
8179 
      if ftype == TType.STOP:
8180 
        break
8181 
      if fid == 1:
8182 
        if ftype == TType.STRUCT:
8183 
          self.cex = CatalogServiceException()
8184 
          self.cex.read(iprot)
8185 
        else:
8186 
          iprot.skip(ftype)
8187 
      else:
8188 
        iprot.skip(ftype)
8189 
      iprot.readFieldEnd()
8190 
    iprot.readStructEnd()
8191 
 
8192 
  def write(self, oprot):
8193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8195 
      return
8196 
    oprot.writeStructBegin('startItemOn_result')
8197 
    if self.cex is not None:
8198 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8199 
      self.cex.write(oprot)
8200 
      oprot.writeFieldEnd()
8201 
    oprot.writeFieldStop()
8202 
    oprot.writeStructEnd()
8203 
 
8204 
  def validate(self):
8205 
    return
8206 
 
8207 
 
8208 
  def __repr__(self):
8209 
    L = ['%s=%r' % (key, value)
8210 
      for key, value in self.__dict__.iteritems()]
8211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8212 
 
8213 
  def __eq__(self, other):
8214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8215 
 
8216 
  def __ne__(self, other):
8217 
    return not (self == other)
8218 
 
8219 
class retireItemOn_args:
8220 
  """
8221 
  Attributes:
8222 
   - item_id
8223 
   - timestamp
8224 
  """
8225 
 
8226 
  thrift_spec = (
8227 
    None, # 0
8228 
    (1, TType.I64, 'item_id', None, None, ), # 1
8229 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8230 
  )
8231 
 
8232 
  def __init__(self, item_id=None, timestamp=None,):
8233 
    self.item_id = item_id
8234 
    self.timestamp = timestamp
8235 
 
8236 
  def read(self, iprot):
8237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8239 
      return
8240 
    iprot.readStructBegin()
8241 
    while True:
8242 
      (fname, ftype, fid) = iprot.readFieldBegin()
8243 
      if ftype == TType.STOP:
8244 
        break
8245 
      if fid == 1:
8246 
        if ftype == TType.I64:
8247 
          self.item_id = iprot.readI64();
8248 
        else:
8249 
          iprot.skip(ftype)
8250 
      elif fid == 2:
8251 
        if ftype == TType.I64:
8252 
          self.timestamp = iprot.readI64();
8253 
        else:
8254 
          iprot.skip(ftype)
8255 
      else:
8256 
        iprot.skip(ftype)
8257 
      iprot.readFieldEnd()
8258 
    iprot.readStructEnd()
8259 
 
8260 
  def write(self, oprot):
8261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8263 
      return
8264 
    oprot.writeStructBegin('retireItemOn_args')
8265 
    if self.item_id is not None:
8266 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8267 
      oprot.writeI64(self.item_id)
8268 
      oprot.writeFieldEnd()
8269 
    if self.timestamp is not None:
8270 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8271 
      oprot.writeI64(self.timestamp)
8272 
      oprot.writeFieldEnd()
8273 
    oprot.writeFieldStop()
8274 
    oprot.writeStructEnd()
8275 
 
8276 
  def validate(self):
8277 
    return
8278 
 
8279 
 
8280 
  def __repr__(self):
8281 
    L = ['%s=%r' % (key, value)
8282 
      for key, value in self.__dict__.iteritems()]
8283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8284 
 
8285 
  def __eq__(self, other):
8286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8287 
 
8288 
  def __ne__(self, other):
8289 
    return not (self == other)
8290 
 
8291 
class retireItemOn_result:
8292 
  """
8293 
  Attributes:
8294 
   - cex
8295 
  """
8296 
 
8297 
  thrift_spec = (
8298 
    None, # 0
8299 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8300 
  )
8301 
 
8302 
  def __init__(self, cex=None,):
8303 
    self.cex = cex
8304 
 
8305 
  def read(self, iprot):
8306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8308 
      return
8309 
    iprot.readStructBegin()
8310 
    while True:
8311 
      (fname, ftype, fid) = iprot.readFieldBegin()
8312 
      if ftype == TType.STOP:
8313 
        break
8314 
      if fid == 1:
8315 
        if ftype == TType.STRUCT:
8316 
          self.cex = CatalogServiceException()
8317 
          self.cex.read(iprot)
8318 
        else:
8319 
          iprot.skip(ftype)
8320 
      else:
8321 
        iprot.skip(ftype)
8322 
      iprot.readFieldEnd()
8323 
    iprot.readStructEnd()
8324 
 
8325 
  def write(self, oprot):
8326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8328 
      return
8329 
    oprot.writeStructBegin('retireItemOn_result')
8330 
    if self.cex is not None:
8331 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8332 
      self.cex.write(oprot)
8333 
      oprot.writeFieldEnd()
8334 
    oprot.writeFieldStop()
8335 
    oprot.writeStructEnd()
8336 
 
8337 
  def validate(self):
8338 
    return
8339 
 
8340 
 
8341 
  def __repr__(self):
8342 
    L = ['%s=%r' % (key, value)
8343 
      for key, value in self.__dict__.iteritems()]
8344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8345 
 
8346 
  def __eq__(self, other):
8347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8348 
 
8349 
  def __ne__(self, other):
8350 
    return not (self == other)
8351 
 
8352 
class changeItemStatus_args:
8353 
  """
8354 
  Attributes:
8355 
   - item_id
8356 
   - timestamp
8357 
   - newstatus
8358 
  """
8359 
 
8360 
  thrift_spec = (
8361 
    None, # 0
8362 
    (1, TType.I64, 'item_id', None, None, ), # 1
8363 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8364 
    (3, TType.I32, 'newstatus', None, None, ), # 3
8365 
  )
8366 
 
8367 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
8368 
    self.item_id = item_id
8369 
    self.timestamp = timestamp
8370 
    self.newstatus = newstatus
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 == 1:
8382 
        if ftype == TType.I64:
8383 
          self.item_id = iprot.readI64();
8384 
        else:
8385 
          iprot.skip(ftype)
8386 
      elif fid == 2:
8387 
        if ftype == TType.I64:
8388 
          self.timestamp = iprot.readI64();
8389 
        else:
8390 
          iprot.skip(ftype)
8391 
      elif fid == 3:
8392 
        if ftype == TType.I32:
8393 
          self.newstatus = iprot.readI32();
8394 
        else:
8395 
          iprot.skip(ftype)
8396 
      else:
8397 
        iprot.skip(ftype)
8398 
      iprot.readFieldEnd()
8399 
    iprot.readStructEnd()
8400 
 
8401 
  def write(self, oprot):
8402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8404 
      return
8405 
    oprot.writeStructBegin('changeItemStatus_args')
8406 
    if self.item_id is not None:
8407 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8408 
      oprot.writeI64(self.item_id)
8409 
      oprot.writeFieldEnd()
8410 
    if self.timestamp is not None:
8411 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8412 
      oprot.writeI64(self.timestamp)
8413 
      oprot.writeFieldEnd()
8414 
    if self.newstatus is not None:
8415 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
8416 
      oprot.writeI32(self.newstatus)
8417 
      oprot.writeFieldEnd()
8418 
    oprot.writeFieldStop()
8419 
    oprot.writeStructEnd()
8420 
 
8421 
  def validate(self):
8422 
    return
8423 
 
8424 
 
8425 
  def __repr__(self):
8426 
    L = ['%s=%r' % (key, value)
8427 
      for key, value in self.__dict__.iteritems()]
8428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8429 
 
8430 
  def __eq__(self, other):
8431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8432 
 
8433 
  def __ne__(self, other):
8434 
    return not (self == other)
8435 
 
8436 
class changeItemStatus_result:
8437 
  """
8438 
  Attributes:
8439 
   - cex
8440 
  """
8441 
 
8442 
  thrift_spec = (
8443 
    None, # 0
8444 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8445 
  )
8446 
 
8447 
  def __init__(self, cex=None,):
8448 
    self.cex = cex
8449 
 
8450 
  def read(self, iprot):
8451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8453 
      return
8454 
    iprot.readStructBegin()
8455 
    while True:
8456 
      (fname, ftype, fid) = iprot.readFieldBegin()
8457 
      if ftype == TType.STOP:
8458 
        break
8459 
      if fid == 1:
8460 
        if ftype == TType.STRUCT:
8461 
          self.cex = CatalogServiceException()
8462 
          self.cex.read(iprot)
8463 
        else:
8464 
          iprot.skip(ftype)
8465 
      else:
8466 
        iprot.skip(ftype)
8467 
      iprot.readFieldEnd()
8468 
    iprot.readStructEnd()
8469 
 
8470 
  def write(self, oprot):
8471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8473 
      return
8474 
    oprot.writeStructBegin('changeItemStatus_result')
8475 
    if self.cex is not None:
8476 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8477 
      self.cex.write(oprot)
8478 
      oprot.writeFieldEnd()
8479 
    oprot.writeFieldStop()
8480 
    oprot.writeStructEnd()
8481 
 
8482 
  def validate(self):
8483 
    return
8484 
 
8485 
 
8486 
  def __repr__(self):
8487 
    L = ['%s=%r' % (key, value)
8488 
      for key, value in self.__dict__.iteritems()]
8489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8490 
 
8491 
  def __eq__(self, other):
8492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8493 
 
8494 
  def __ne__(self, other):
8495 
    return not (self == other)
8496 
 
8497 
class getItem_args:
8498 
  """
8499 
  Attributes:
8500 
   - item_id
8501 
  """
8502 
 
8503 
  thrift_spec = (
8504 
    None, # 0
8505 
    (1, TType.I64, 'item_id', None, None, ), # 1
8506 
  )
8507 
 
8508 
  def __init__(self, item_id=None,):
8509 
    self.item_id = item_id
8510 
 
8511 
  def read(self, iprot):
8512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8514 
      return
8515 
    iprot.readStructBegin()
8516 
    while True:
8517 
      (fname, ftype, fid) = iprot.readFieldBegin()
8518 
      if ftype == TType.STOP:
8519 
        break
8520 
      if fid == 1:
8521 
        if ftype == TType.I64:
8522 
          self.item_id = iprot.readI64();
8523 
        else:
8524 
          iprot.skip(ftype)
8525 
      else:
8526 
        iprot.skip(ftype)
8527 
      iprot.readFieldEnd()
8528 
    iprot.readStructEnd()
8529 
 
8530 
  def write(self, oprot):
8531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8533 
      return
8534 
    oprot.writeStructBegin('getItem_args')
8535 
    if self.item_id is not None:
8536 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8537 
      oprot.writeI64(self.item_id)
8538 
      oprot.writeFieldEnd()
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 getItem_result:
8558 
  """
8559 
  Attributes:
8560 
   - success
8561 
   - cex
8562 
  """
8563 
 
8564 
  thrift_spec = (
8565 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), 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.STRUCT:
8584 
          self.success = Item()
8585 
          self.success.read(iprot)
8586 
        else:
8587 
          iprot.skip(ftype)
8588 
      elif fid == 1:
8589 
        if ftype == TType.STRUCT:
8590 
          self.cex = CatalogServiceException()
8591 
          self.cex.read(iprot)
8592 
        else:
8593 
          iprot.skip(ftype)
8594 
      else:
8595 
        iprot.skip(ftype)
8596 
      iprot.readFieldEnd()
8597 
    iprot.readStructEnd()
8598 
 
8599 
  def write(self, oprot):
8600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8602 
      return
8603 
    oprot.writeStructBegin('getItem_result')
8604 
    if self.success is not None:
8605 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8606 
      self.success.write(oprot)
8607 
      oprot.writeFieldEnd()
8608 
    if self.cex is not None:
8609 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8610 
      self.cex.write(oprot)
8611 
      oprot.writeFieldEnd()
8612 
    oprot.writeFieldStop()
8613 
    oprot.writeStructEnd()
8614 
 
8615 
  def validate(self):
8616 
    return
8617 
 
8618 
 
8619 
  def __repr__(self):
8620 
    L = ['%s=%r' % (key, value)
8621 
      for key, value in self.__dict__.iteritems()]
8622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8623 
 
8624 
  def __eq__(self, other):
8625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8626 
 
8627 
  def __ne__(self, other):
8628 
    return not (self == other)
8629 
 
8630 
class getItemsByCatalogId_args:
8631 
  """
8632 
  Attributes:
8633 
   - catalog_item_id
8634 
  """
8635 
 
8636 
  thrift_spec = (
8637 
    None, # 0
8638 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8639 
  )
8640 
 
8641 
  def __init__(self, catalog_item_id=None,):
8642 
    self.catalog_item_id = catalog_item_id
8643 
 
8644 
  def read(self, iprot):
8645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8647 
      return
8648 
    iprot.readStructBegin()
8649 
    while True:
8650 
      (fname, ftype, fid) = iprot.readFieldBegin()
8651 
      if ftype == TType.STOP:
8652 
        break
8653 
      if fid == 1:
8654 
        if ftype == TType.I64:
8655 
          self.catalog_item_id = iprot.readI64();
8656 
        else:
8657 
          iprot.skip(ftype)
8658 
      else:
8659 
        iprot.skip(ftype)
8660 
      iprot.readFieldEnd()
8661 
    iprot.readStructEnd()
8662 
 
8663 
  def write(self, oprot):
8664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8666 
      return
8667 
    oprot.writeStructBegin('getItemsByCatalogId_args')
8668 
    if self.catalog_item_id is not None:
8669 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8670 
      oprot.writeI64(self.catalog_item_id)
8671 
      oprot.writeFieldEnd()
8672 
    oprot.writeFieldStop()
8673 
    oprot.writeStructEnd()
8674 
 
8675 
  def validate(self):
8676 
    return
8677 
 
8678 
 
8679 
  def __repr__(self):
8680 
    L = ['%s=%r' % (key, value)
8681 
      for key, value in self.__dict__.iteritems()]
8682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8683 
 
8684 
  def __eq__(self, other):
8685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8686 
 
8687 
  def __ne__(self, other):
8688 
    return not (self == other)
8689 
 
8690 
class getItemsByCatalogId_result:
8691 
  """
8692 
  Attributes:
8693 
   - success
8694 
   - cex
8695 
  """
8696 
 
8697 
  thrift_spec = (
8698 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8699 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8700 
  )
8701 
 
8702 
  def __init__(self, success=None, cex=None,):
8703 
    self.success = success
8704 
    self.cex = cex
8705 
 
8706 
  def read(self, iprot):
8707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8709 
      return
8710 
    iprot.readStructBegin()
8711 
    while True:
8712 
      (fname, ftype, fid) = iprot.readFieldBegin()
8713 
      if ftype == TType.STOP:
8714 
        break
8715 
      if fid == 0:
8716 
        if ftype == TType.LIST:
8717 
          self.success = []
8590 kshitij.so 8718 
          (_etype49, _size46) = iprot.readListBegin()
8719 
          for _i50 in xrange(_size46):
8720 
            _elem51 = Item()
8721 
            _elem51.read(iprot)
8722 
            self.success.append(_elem51)
5944 mandeep.dh 8723 
          iprot.readListEnd()
8724 
        else:
8725 
          iprot.skip(ftype)
8726 
      elif fid == 1:
8727 
        if ftype == TType.STRUCT:
8728 
          self.cex = CatalogServiceException()
8729 
          self.cex.read(iprot)
8730 
        else:
8731 
          iprot.skip(ftype)
8732 
      else:
8733 
        iprot.skip(ftype)
8734 
      iprot.readFieldEnd()
8735 
    iprot.readStructEnd()
8736 
 
8737 
  def write(self, oprot):
8738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8740 
      return
8741 
    oprot.writeStructBegin('getItemsByCatalogId_result')
8742 
    if self.success is not None:
8743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8744 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8745 
      for iter52 in self.success:
8746 
        iter52.write(oprot)
5944 mandeep.dh 8747 
      oprot.writeListEnd()
8748 
      oprot.writeFieldEnd()
8749 
    if self.cex is not None:
8750 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8751 
      self.cex.write(oprot)
8752 
      oprot.writeFieldEnd()
8753 
    oprot.writeFieldStop()
8754 
    oprot.writeStructEnd()
8755 
 
8756 
  def validate(self):
8757 
    return
8758 
 
8759 
 
8760 
  def __repr__(self):
8761 
    L = ['%s=%r' % (key, value)
8762 
      for key, value in self.__dict__.iteritems()]
8763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8764 
 
8765 
  def __eq__(self, other):
8766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8767 
 
8768 
  def __ne__(self, other):
8769 
    return not (self == other)
8770 
 
8771 
class getValidItemsByCatalogId_args:
8772 
  """
8773 
  Attributes:
8774 
   - catalog_item_id
8775 
  """
8776 
 
8777 
  thrift_spec = (
8778 
    None, # 0
8779 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8780 
  )
8781 
 
8782 
  def __init__(self, catalog_item_id=None,):
8783 
    self.catalog_item_id = catalog_item_id
8784 
 
8785 
  def read(self, iprot):
8786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8788 
      return
8789 
    iprot.readStructBegin()
8790 
    while True:
8791 
      (fname, ftype, fid) = iprot.readFieldBegin()
8792 
      if ftype == TType.STOP:
8793 
        break
8794 
      if fid == 1:
8795 
        if ftype == TType.I64:
8796 
          self.catalog_item_id = iprot.readI64();
8797 
        else:
8798 
          iprot.skip(ftype)
8799 
      else:
8800 
        iprot.skip(ftype)
8801 
      iprot.readFieldEnd()
8802 
    iprot.readStructEnd()
8803 
 
8804 
  def write(self, oprot):
8805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8807 
      return
8808 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
8809 
    if self.catalog_item_id is not None:
8810 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8811 
      oprot.writeI64(self.catalog_item_id)
8812 
      oprot.writeFieldEnd()
8813 
    oprot.writeFieldStop()
8814 
    oprot.writeStructEnd()
8815 
 
8816 
  def validate(self):
8817 
    return
8818 
 
8819 
 
8820 
  def __repr__(self):
8821 
    L = ['%s=%r' % (key, value)
8822 
      for key, value in self.__dict__.iteritems()]
8823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8824 
 
8825 
  def __eq__(self, other):
8826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8827 
 
8828 
  def __ne__(self, other):
8829 
    return not (self == other)
8830 
 
8831 
class getValidItemsByCatalogId_result:
8832 
  """
8833 
  Attributes:
8834 
   - success
8835 
   - cex
8836 
  """
8837 
 
8838 
  thrift_spec = (
8839 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8840 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8841 
  )
8842 
 
8843 
  def __init__(self, success=None, cex=None,):
8844 
    self.success = success
8845 
    self.cex = cex
8846 
 
8847 
  def read(self, iprot):
8848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8850 
      return
8851 
    iprot.readStructBegin()
8852 
    while True:
8853 
      (fname, ftype, fid) = iprot.readFieldBegin()
8854 
      if ftype == TType.STOP:
8855 
        break
8856 
      if fid == 0:
8857 
        if ftype == TType.LIST:
8858 
          self.success = []
8590 kshitij.so 8859 
          (_etype56, _size53) = iprot.readListBegin()
8860 
          for _i57 in xrange(_size53):
8861 
            _elem58 = Item()
8862 
            _elem58.read(iprot)
8863 
            self.success.append(_elem58)
5944 mandeep.dh 8864 
          iprot.readListEnd()
8865 
        else:
8866 
          iprot.skip(ftype)
8867 
      elif fid == 1:
8868 
        if ftype == TType.STRUCT:
8869 
          self.cex = CatalogServiceException()
8870 
          self.cex.read(iprot)
8871 
        else:
8872 
          iprot.skip(ftype)
8873 
      else:
8874 
        iprot.skip(ftype)
8875 
      iprot.readFieldEnd()
8876 
    iprot.readStructEnd()
8877 
 
8878 
  def write(self, oprot):
8879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8881 
      return
8882 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
8883 
    if self.success is not None:
8884 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8885 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8886 
      for iter59 in self.success:
8887 
        iter59.write(oprot)
5944 mandeep.dh 8888 
      oprot.writeListEnd()
8889 
      oprot.writeFieldEnd()
8890 
    if self.cex is not None:
8891 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8892 
      self.cex.write(oprot)
8893 
      oprot.writeFieldEnd()
8894 
    oprot.writeFieldStop()
8895 
    oprot.writeStructEnd()
8896 
 
8897 
  def validate(self):
8898 
    return
8899 
 
8900 
 
8901 
  def __repr__(self):
8902 
    L = ['%s=%r' % (key, value)
8903 
      for key, value in self.__dict__.iteritems()]
8904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8905 
 
8906 
  def __eq__(self, other):
8907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8908 
 
8909 
  def __ne__(self, other):
8910 
    return not (self == other)
8911 
 
8912 
class getAllItems_args:
8913 
  """
8914 
  Attributes:
8915 
   - isActive
8916 
  """
8917 
 
8918 
  thrift_spec = (
8919 
    None, # 0
8920 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
8921 
  )
8922 
 
8923 
  def __init__(self, isActive=None,):
8924 
    self.isActive = isActive
8925 
 
8926 
  def read(self, iprot):
8927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8929 
      return
8930 
    iprot.readStructBegin()
8931 
    while True:
8932 
      (fname, ftype, fid) = iprot.readFieldBegin()
8933 
      if ftype == TType.STOP:
8934 
        break
8935 
      if fid == 1:
8936 
        if ftype == TType.BOOL:
8937 
          self.isActive = iprot.readBool();
8938 
        else:
8939 
          iprot.skip(ftype)
8940 
      else:
8941 
        iprot.skip(ftype)
8942 
      iprot.readFieldEnd()
8943 
    iprot.readStructEnd()
8944 
 
8945 
  def write(self, oprot):
8946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8948 
      return
8949 
    oprot.writeStructBegin('getAllItems_args')
8950 
    if self.isActive is not None:
8951 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
8952 
      oprot.writeBool(self.isActive)
8953 
      oprot.writeFieldEnd()
8954 
    oprot.writeFieldStop()
8955 
    oprot.writeStructEnd()
8956 
 
8957 
  def validate(self):
8958 
    return
8959 
 
8960 
 
8961 
  def __repr__(self):
8962 
    L = ['%s=%r' % (key, value)
8963 
      for key, value in self.__dict__.iteritems()]
8964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8965 
 
8966 
  def __eq__(self, other):
8967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8968 
 
8969 
  def __ne__(self, other):
8970 
    return not (self == other)
8971 
 
8972 
class getAllItems_result:
8973 
  """
8974 
  Attributes:
8975 
   - success
8976 
   - cex
8977 
  """
8978 
 
8979 
  thrift_spec = (
8980 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8981 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8982 
  )
8983 
 
8984 
  def __init__(self, success=None, cex=None,):
8985 
    self.success = success
8986 
    self.cex = cex
8987 
 
8988 
  def read(self, iprot):
8989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8991 
      return
8992 
    iprot.readStructBegin()
8993 
    while True:
8994 
      (fname, ftype, fid) = iprot.readFieldBegin()
8995 
      if ftype == TType.STOP:
8996 
        break
8997 
      if fid == 0:
8998 
        if ftype == TType.LIST:
8999 
          self.success = []
8590 kshitij.so 9000 
          (_etype63, _size60) = iprot.readListBegin()
9001 
          for _i64 in xrange(_size60):
9002 
            _elem65 = Item()
9003 
            _elem65.read(iprot)
9004 
            self.success.append(_elem65)
5944 mandeep.dh 9005 
          iprot.readListEnd()
9006 
        else:
9007 
          iprot.skip(ftype)
9008 
      elif fid == 1:
9009 
        if ftype == TType.STRUCT:
9010 
          self.cex = CatalogServiceException()
9011 
          self.cex.read(iprot)
9012 
        else:
9013 
          iprot.skip(ftype)
9014 
      else:
9015 
        iprot.skip(ftype)
9016 
      iprot.readFieldEnd()
9017 
    iprot.readStructEnd()
9018 
 
9019 
  def write(self, oprot):
9020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9022 
      return
9023 
    oprot.writeStructBegin('getAllItems_result')
9024 
    if self.success is not None:
9025 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9026 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9027 
      for iter66 in self.success:
9028 
        iter66.write(oprot)
5944 mandeep.dh 9029 
      oprot.writeListEnd()
9030 
      oprot.writeFieldEnd()
9031 
    if self.cex is not None:
9032 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9033 
      self.cex.write(oprot)
9034 
      oprot.writeFieldEnd()
9035 
    oprot.writeFieldStop()
9036 
    oprot.writeStructEnd()
9037 
 
9038 
  def validate(self):
9039 
    return
9040 
 
9041 
 
9042 
  def __repr__(self):
9043 
    L = ['%s=%r' % (key, value)
9044 
      for key, value in self.__dict__.iteritems()]
9045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9046 
 
9047 
  def __eq__(self, other):
9048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9049 
 
9050 
  def __ne__(self, other):
9051 
    return not (self == other)
9052 
 
9053 
class getAllItemsByStatus_args:
9054 
  """
9055 
  Attributes:
9056 
   - itemStatus
9057 
  """
9058 
 
9059 
  thrift_spec = (
9060 
    None, # 0
9061 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9062 
  )
9063 
 
9064 
  def __init__(self, itemStatus=None,):
9065 
    self.itemStatus = itemStatus
9066 
 
9067 
  def read(self, iprot):
9068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9070 
      return
9071 
    iprot.readStructBegin()
9072 
    while True:
9073 
      (fname, ftype, fid) = iprot.readFieldBegin()
9074 
      if ftype == TType.STOP:
9075 
        break
9076 
      if fid == 1:
9077 
        if ftype == TType.I32:
9078 
          self.itemStatus = iprot.readI32();
9079 
        else:
9080 
          iprot.skip(ftype)
9081 
      else:
9082 
        iprot.skip(ftype)
9083 
      iprot.readFieldEnd()
9084 
    iprot.readStructEnd()
9085 
 
9086 
  def write(self, oprot):
9087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9089 
      return
9090 
    oprot.writeStructBegin('getAllItemsByStatus_args')
9091 
    if self.itemStatus is not None:
9092 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9093 
      oprot.writeI32(self.itemStatus)
9094 
      oprot.writeFieldEnd()
9095 
    oprot.writeFieldStop()
9096 
    oprot.writeStructEnd()
9097 
 
9098 
  def validate(self):
9099 
    return
9100 
 
9101 
 
9102 
  def __repr__(self):
9103 
    L = ['%s=%r' % (key, value)
9104 
      for key, value in self.__dict__.iteritems()]
9105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9106 
 
9107 
  def __eq__(self, other):
9108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9109 
 
9110 
  def __ne__(self, other):
9111 
    return not (self == other)
9112 
 
9113 
class getAllItemsByStatus_result:
9114 
  """
9115 
  Attributes:
9116 
   - success
9117 
   - cex
9118 
  """
9119 
 
9120 
  thrift_spec = (
9121 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9122 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9123 
  )
9124 
 
9125 
  def __init__(self, success=None, cex=None,):
9126 
    self.success = success
9127 
    self.cex = cex
9128 
 
9129 
  def read(self, iprot):
9130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9132 
      return
9133 
    iprot.readStructBegin()
9134 
    while True:
9135 
      (fname, ftype, fid) = iprot.readFieldBegin()
9136 
      if ftype == TType.STOP:
9137 
        break
9138 
      if fid == 0:
9139 
        if ftype == TType.LIST:
9140 
          self.success = []
8590 kshitij.so 9141 
          (_etype70, _size67) = iprot.readListBegin()
9142 
          for _i71 in xrange(_size67):
9143 
            _elem72 = Item()
9144 
            _elem72.read(iprot)
9145 
            self.success.append(_elem72)
5944 mandeep.dh 9146 
          iprot.readListEnd()
9147 
        else:
9148 
          iprot.skip(ftype)
9149 
      elif fid == 1:
9150 
        if ftype == TType.STRUCT:
9151 
          self.cex = CatalogServiceException()
9152 
          self.cex.read(iprot)
9153 
        else:
9154 
          iprot.skip(ftype)
9155 
      else:
9156 
        iprot.skip(ftype)
9157 
      iprot.readFieldEnd()
9158 
    iprot.readStructEnd()
9159 
 
9160 
  def write(self, oprot):
9161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9163 
      return
9164 
    oprot.writeStructBegin('getAllItemsByStatus_result')
9165 
    if self.success is not None:
9166 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9167 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9168 
      for iter73 in self.success:
9169 
        iter73.write(oprot)
5944 mandeep.dh 9170 
      oprot.writeListEnd()
9171 
      oprot.writeFieldEnd()
9172 
    if self.cex is not None:
9173 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9174 
      self.cex.write(oprot)
9175 
      oprot.writeFieldEnd()
9176 
    oprot.writeFieldStop()
9177 
    oprot.writeStructEnd()
9178 
 
9179 
  def validate(self):
9180 
    return
9181 
 
9182 
 
9183 
  def __repr__(self):
9184 
    L = ['%s=%r' % (key, value)
9185 
      for key, value in self.__dict__.iteritems()]
9186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9187 
 
9188 
  def __eq__(self, other):
9189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9190 
 
9191 
  def __ne__(self, other):
9192 
    return not (self == other)
9193 
 
9194 
class markItemAsContentComplete_args:
9195 
  """
9196 
  Attributes:
9197 
   - entityId
9198 
   - category
9199 
   - brand
9200 
   - modelName
9201 
   - modelNumber
9253 rajveer 9202 
   - isAndroid
5944 mandeep.dh 9203 
  """
9204 
 
9205 
  thrift_spec = (
9206 
    None, # 0
9207 
    (1, TType.I64, 'entityId', None, None, ), # 1
9208 
    (2, TType.I64, 'category', None, None, ), # 2
9209 
    (3, TType.STRING, 'brand', None, None, ), # 3
9210 
    (4, TType.STRING, 'modelName', None, None, ), # 4
9211 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 9212 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 9213 
  )
9214 
 
9253 rajveer 9215 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 9216 
    self.entityId = entityId
9217 
    self.category = category
9218 
    self.brand = brand
9219 
    self.modelName = modelName
9220 
    self.modelNumber = modelNumber
9253 rajveer 9221 
    self.isAndroid = isAndroid
5944 mandeep.dh 9222 
 
9223 
  def read(self, iprot):
9224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9226 
      return
9227 
    iprot.readStructBegin()
9228 
    while True:
9229 
      (fname, ftype, fid) = iprot.readFieldBegin()
9230 
      if ftype == TType.STOP:
9231 
        break
9232 
      if fid == 1:
9233 
        if ftype == TType.I64:
9234 
          self.entityId = iprot.readI64();
9235 
        else:
9236 
          iprot.skip(ftype)
9237 
      elif fid == 2:
9238 
        if ftype == TType.I64:
9239 
          self.category = iprot.readI64();
9240 
        else:
9241 
          iprot.skip(ftype)
9242 
      elif fid == 3:
9243 
        if ftype == TType.STRING:
9244 
          self.brand = iprot.readString();
9245 
        else:
9246 
          iprot.skip(ftype)
9247 
      elif fid == 4:
9248 
        if ftype == TType.STRING:
9249 
          self.modelName = iprot.readString();
9250 
        else:
9251 
          iprot.skip(ftype)
9252 
      elif fid == 5:
9253 
        if ftype == TType.STRING:
9254 
          self.modelNumber = iprot.readString();
9255 
        else:
9256 
          iprot.skip(ftype)
9253 rajveer 9257 
      elif fid == 6:
9258 
        if ftype == TType.BOOL:
9259 
          self.isAndroid = iprot.readBool();
9260 
        else:
9261 
          iprot.skip(ftype)
5944 mandeep.dh 9262 
      else:
9263 
        iprot.skip(ftype)
9264 
      iprot.readFieldEnd()
9265 
    iprot.readStructEnd()
9266 
 
9267 
  def write(self, oprot):
9268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9270 
      return
9271 
    oprot.writeStructBegin('markItemAsContentComplete_args')
9272 
    if self.entityId is not None:
9273 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
9274 
      oprot.writeI64(self.entityId)
9275 
      oprot.writeFieldEnd()
9276 
    if self.category is not None:
9277 
      oprot.writeFieldBegin('category', TType.I64, 2)
9278 
      oprot.writeI64(self.category)
9279 
      oprot.writeFieldEnd()
9280 
    if self.brand is not None:
9281 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9282 
      oprot.writeString(self.brand)
9283 
      oprot.writeFieldEnd()
9284 
    if self.modelName is not None:
9285 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
9286 
      oprot.writeString(self.modelName)
9287 
      oprot.writeFieldEnd()
9288 
    if self.modelNumber is not None:
9289 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
9290 
      oprot.writeString(self.modelNumber)
9291 
      oprot.writeFieldEnd()
9253 rajveer 9292 
    if self.isAndroid is not None:
9293 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
9294 
      oprot.writeBool(self.isAndroid)
9295 
      oprot.writeFieldEnd()
5944 mandeep.dh 9296 
    oprot.writeFieldStop()
9297 
    oprot.writeStructEnd()
9298 
 
9299 
  def validate(self):
9300 
    return
9301 
 
9302 
 
9303 
  def __repr__(self):
9304 
    L = ['%s=%r' % (key, value)
9305 
      for key, value in self.__dict__.iteritems()]
9306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9307 
 
9308 
  def __eq__(self, other):
9309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9310 
 
9311 
  def __ne__(self, other):
9312 
    return not (self == other)
9313 
 
9314 
class markItemAsContentComplete_result:
9315 
  """
9316 
  Attributes:
9317 
   - success
9318 
   - cex
9319 
  """
9320 
 
9321 
  thrift_spec = (
9322 
    (0, TType.BOOL, 'success', None, None, ), # 0
9323 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9324 
  )
9325 
 
9326 
  def __init__(self, success=None, cex=None,):
9327 
    self.success = success
9328 
    self.cex = cex
9329 
 
9330 
  def read(self, iprot):
9331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9333 
      return
9334 
    iprot.readStructBegin()
9335 
    while True:
9336 
      (fname, ftype, fid) = iprot.readFieldBegin()
9337 
      if ftype == TType.STOP:
9338 
        break
9339 
      if fid == 0:
9340 
        if ftype == TType.BOOL:
9341 
          self.success = iprot.readBool();
9342 
        else:
9343 
          iprot.skip(ftype)
9344 
      elif fid == 1:
9345 
        if ftype == TType.STRUCT:
9346 
          self.cex = CatalogServiceException()
9347 
          self.cex.read(iprot)
9348 
        else:
9349 
          iprot.skip(ftype)
9350 
      else:
9351 
        iprot.skip(ftype)
9352 
      iprot.readFieldEnd()
9353 
    iprot.readStructEnd()
9354 
 
9355 
  def write(self, oprot):
9356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9358 
      return
9359 
    oprot.writeStructBegin('markItemAsContentComplete_result')
9360 
    if self.success is not None:
9361 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9362 
      oprot.writeBool(self.success)
9363 
      oprot.writeFieldEnd()
9364 
    if self.cex is not None:
9365 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9366 
      self.cex.write(oprot)
9367 
      oprot.writeFieldEnd()
9368 
    oprot.writeFieldStop()
9369 
    oprot.writeStructEnd()
9370 
 
9371 
  def validate(self):
9372 
    return
9373 
 
9374 
 
9375 
  def __repr__(self):
9376 
    L = ['%s=%r' % (key, value)
9377 
      for key, value in self.__dict__.iteritems()]
9378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9379 
 
9380 
  def __eq__(self, other):
9381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9382 
 
9383 
  def __ne__(self, other):
9384 
    return not (self == other)
9385 
 
9386 
class getAllItemsInRange_args:
9387 
  """
9388 
  Attributes:
9389 
   - offset
9390 
   - limit
9391 
  """
9392 
 
9393 
  thrift_spec = (
9394 
    None, # 0
9395 
    (1, TType.I64, 'offset', None, None, ), # 1
9396 
    (2, TType.I64, 'limit', None, None, ), # 2
9397 
  )
9398 
 
9399 
  def __init__(self, offset=None, limit=None,):
9400 
    self.offset = offset
9401 
    self.limit = limit
9402 
 
9403 
  def read(self, iprot):
9404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9406 
      return
9407 
    iprot.readStructBegin()
9408 
    while True:
9409 
      (fname, ftype, fid) = iprot.readFieldBegin()
9410 
      if ftype == TType.STOP:
9411 
        break
9412 
      if fid == 1:
9413 
        if ftype == TType.I64:
9414 
          self.offset = iprot.readI64();
9415 
        else:
9416 
          iprot.skip(ftype)
9417 
      elif fid == 2:
9418 
        if ftype == TType.I64:
9419 
          self.limit = iprot.readI64();
9420 
        else:
9421 
          iprot.skip(ftype)
9422 
      else:
9423 
        iprot.skip(ftype)
9424 
      iprot.readFieldEnd()
9425 
    iprot.readStructEnd()
9426 
 
9427 
  def write(self, oprot):
9428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9430 
      return
9431 
    oprot.writeStructBegin('getAllItemsInRange_args')
9432 
    if self.offset is not None:
9433 
      oprot.writeFieldBegin('offset', TType.I64, 1)
9434 
      oprot.writeI64(self.offset)
9435 
      oprot.writeFieldEnd()
9436 
    if self.limit is not None:
9437 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9438 
      oprot.writeI64(self.limit)
9439 
      oprot.writeFieldEnd()
9440 
    oprot.writeFieldStop()
9441 
    oprot.writeStructEnd()
9442 
 
9443 
  def validate(self):
9444 
    return
9445 
 
9446 
 
9447 
  def __repr__(self):
9448 
    L = ['%s=%r' % (key, value)
9449 
      for key, value in self.__dict__.iteritems()]
9450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9451 
 
9452 
  def __eq__(self, other):
9453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9454 
 
9455 
  def __ne__(self, other):
9456 
    return not (self == other)
9457 
 
9458 
class getAllItemsInRange_result:
9459 
  """
9460 
  Attributes:
9461 
   - success
9462 
   - cex
9463 
  """
9464 
 
9465 
  thrift_spec = (
9466 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9467 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9468 
  )
9469 
 
9470 
  def __init__(self, success=None, cex=None,):
9471 
    self.success = success
9472 
    self.cex = cex
9473 
 
9474 
  def read(self, iprot):
9475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9477 
      return
9478 
    iprot.readStructBegin()
9479 
    while True:
9480 
      (fname, ftype, fid) = iprot.readFieldBegin()
9481 
      if ftype == TType.STOP:
9482 
        break
9483 
      if fid == 0:
9484 
        if ftype == TType.LIST:
9485 
          self.success = []
8590 kshitij.so 9486 
          (_etype77, _size74) = iprot.readListBegin()
9487 
          for _i78 in xrange(_size74):
9488 
            _elem79 = Item()
9489 
            _elem79.read(iprot)
9490 
            self.success.append(_elem79)
5944 mandeep.dh 9491 
          iprot.readListEnd()
9492 
        else:
9493 
          iprot.skip(ftype)
9494 
      elif fid == 1:
9495 
        if ftype == TType.STRUCT:
9496 
          self.cex = CatalogServiceException()
9497 
          self.cex.read(iprot)
9498 
        else:
9499 
          iprot.skip(ftype)
9500 
      else:
9501 
        iprot.skip(ftype)
9502 
      iprot.readFieldEnd()
9503 
    iprot.readStructEnd()
9504 
 
9505 
  def write(self, oprot):
9506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9508 
      return
9509 
    oprot.writeStructBegin('getAllItemsInRange_result')
9510 
    if self.success is not None:
9511 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9512 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9513 
      for iter80 in self.success:
9514 
        iter80.write(oprot)
5944 mandeep.dh 9515 
      oprot.writeListEnd()
9516 
      oprot.writeFieldEnd()
9517 
    if self.cex is not None:
9518 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9519 
      self.cex.write(oprot)
9520 
      oprot.writeFieldEnd()
9521 
    oprot.writeFieldStop()
9522 
    oprot.writeStructEnd()
9523 
 
9524 
  def validate(self):
9525 
    return
9526 
 
9527 
 
9528 
  def __repr__(self):
9529 
    L = ['%s=%r' % (key, value)
9530 
      for key, value in self.__dict__.iteritems()]
9531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9532 
 
9533 
  def __eq__(self, other):
9534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9535 
 
9536 
  def __ne__(self, other):
9537 
    return not (self == other)
9538 
 
9539 
class getAllItemsByStatusInRange_args:
9540 
  """
9541 
  Attributes:
9542 
   - itemStatus
9543 
   - offset
9544 
   - limit
9545 
  """
9546 
 
9547 
  thrift_spec = (
9548 
    None, # 0
9549 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9550 
    (2, TType.I64, 'offset', None, None, ), # 2
9551 
    (3, TType.I64, 'limit', None, None, ), # 3
9552 
  )
9553 
 
9554 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
9555 
    self.itemStatus = itemStatus
9556 
    self.offset = offset
9557 
    self.limit = limit
9558 
 
9559 
  def read(self, iprot):
9560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9562 
      return
9563 
    iprot.readStructBegin()
9564 
    while True:
9565 
      (fname, ftype, fid) = iprot.readFieldBegin()
9566 
      if ftype == TType.STOP:
9567 
        break
9568 
      if fid == 1:
9569 
        if ftype == TType.I32:
9570 
          self.itemStatus = iprot.readI32();
9571 
        else:
9572 
          iprot.skip(ftype)
9573 
      elif fid == 2:
9574 
        if ftype == TType.I64:
9575 
          self.offset = iprot.readI64();
9576 
        else:
9577 
          iprot.skip(ftype)
9578 
      elif fid == 3:
9579 
        if ftype == TType.I64:
9580 
          self.limit = iprot.readI64();
9581 
        else:
9582 
          iprot.skip(ftype)
9583 
      else:
9584 
        iprot.skip(ftype)
9585 
      iprot.readFieldEnd()
9586 
    iprot.readStructEnd()
9587 
 
9588 
  def write(self, oprot):
9589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9591 
      return
9592 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
9593 
    if self.itemStatus is not None:
9594 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9595 
      oprot.writeI32(self.itemStatus)
9596 
      oprot.writeFieldEnd()
9597 
    if self.offset is not None:
9598 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9599 
      oprot.writeI64(self.offset)
9600 
      oprot.writeFieldEnd()
9601 
    if self.limit is not None:
9602 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9603 
      oprot.writeI64(self.limit)
9604 
      oprot.writeFieldEnd()
9605 
    oprot.writeFieldStop()
9606 
    oprot.writeStructEnd()
9607 
 
9608 
  def validate(self):
9609 
    return
9610 
 
9611 
 
9612 
  def __repr__(self):
9613 
    L = ['%s=%r' % (key, value)
9614 
      for key, value in self.__dict__.iteritems()]
9615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9616 
 
9617 
  def __eq__(self, other):
9618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9619 
 
9620 
  def __ne__(self, other):
9621 
    return not (self == other)
9622 
 
9623 
class getAllItemsByStatusInRange_result:
9624 
  """
9625 
  Attributes:
9626 
   - success
9627 
   - cex
9628 
  """
9629 
 
9630 
  thrift_spec = (
9631 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9632 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9633 
  )
9634 
 
9635 
  def __init__(self, success=None, cex=None,):
9636 
    self.success = success
9637 
    self.cex = cex
9638 
 
9639 
  def read(self, iprot):
9640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9642 
      return
9643 
    iprot.readStructBegin()
9644 
    while True:
9645 
      (fname, ftype, fid) = iprot.readFieldBegin()
9646 
      if ftype == TType.STOP:
9647 
        break
9648 
      if fid == 0:
9649 
        if ftype == TType.LIST:
9650 
          self.success = []
8590 kshitij.so 9651 
          (_etype84, _size81) = iprot.readListBegin()
9652 
          for _i85 in xrange(_size81):
9653 
            _elem86 = Item()
9654 
            _elem86.read(iprot)
9655 
            self.success.append(_elem86)
5944 mandeep.dh 9656 
          iprot.readListEnd()
9657 
        else:
9658 
          iprot.skip(ftype)
9659 
      elif fid == 1:
9660 
        if ftype == TType.STRUCT:
9661 
          self.cex = CatalogServiceException()
9662 
          self.cex.read(iprot)
9663 
        else:
9664 
          iprot.skip(ftype)
9665 
      else:
9666 
        iprot.skip(ftype)
9667 
      iprot.readFieldEnd()
9668 
    iprot.readStructEnd()
9669 
 
9670 
  def write(self, oprot):
9671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9673 
      return
9674 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
9675 
    if self.success is not None:
9676 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9677 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9678 
      for iter87 in self.success:
9679 
        iter87.write(oprot)
5944 mandeep.dh 9680 
      oprot.writeListEnd()
9681 
      oprot.writeFieldEnd()
9682 
    if self.cex is not None:
9683 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9684 
      self.cex.write(oprot)
9685 
      oprot.writeFieldEnd()
9686 
    oprot.writeFieldStop()
9687 
    oprot.writeStructEnd()
9688 
 
9689 
  def validate(self):
9690 
    return
9691 
 
9692 
 
9693 
  def __repr__(self):
9694 
    L = ['%s=%r' % (key, value)
9695 
      for key, value in self.__dict__.iteritems()]
9696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9697 
 
9698 
  def __eq__(self, other):
9699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9700 
 
9701 
  def __ne__(self, other):
9702 
    return not (self == other)
9703 
 
9704 
class getItemCountByStatus_args:
9705 
  """
9706 
  Attributes:
9707 
   - useStatus
9708 
   - itemStatus
9709 
  """
9710 
 
9711 
  thrift_spec = (
9712 
    None, # 0
9713 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
9714 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
9715 
  )
9716 
 
9717 
  def __init__(self, useStatus=None, itemStatus=None,):
9718 
    self.useStatus = useStatus
9719 
    self.itemStatus = itemStatus
9720 
 
9721 
  def read(self, iprot):
9722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9724 
      return
9725 
    iprot.readStructBegin()
9726 
    while True:
9727 
      (fname, ftype, fid) = iprot.readFieldBegin()
9728 
      if ftype == TType.STOP:
9729 
        break
9730 
      if fid == 1:
9731 
        if ftype == TType.BOOL:
9732 
          self.useStatus = iprot.readBool();
9733 
        else:
9734 
          iprot.skip(ftype)
9735 
      elif fid == 2:
9736 
        if ftype == TType.I32:
9737 
          self.itemStatus = iprot.readI32();
9738 
        else:
9739 
          iprot.skip(ftype)
9740 
      else:
9741 
        iprot.skip(ftype)
9742 
      iprot.readFieldEnd()
9743 
    iprot.readStructEnd()
9744 
 
9745 
  def write(self, oprot):
9746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9748 
      return
9749 
    oprot.writeStructBegin('getItemCountByStatus_args')
9750 
    if self.useStatus is not None:
9751 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
9752 
      oprot.writeBool(self.useStatus)
9753 
      oprot.writeFieldEnd()
9754 
    if self.itemStatus is not None:
9755 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
9756 
      oprot.writeI32(self.itemStatus)
9757 
      oprot.writeFieldEnd()
9758 
    oprot.writeFieldStop()
9759 
    oprot.writeStructEnd()
9760 
 
9761 
  def validate(self):
9762 
    return
9763 
 
9764 
 
9765 
  def __repr__(self):
9766 
    L = ['%s=%r' % (key, value)
9767 
      for key, value in self.__dict__.iteritems()]
9768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9769 
 
9770 
  def __eq__(self, other):
9771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9772 
 
9773 
  def __ne__(self, other):
9774 
    return not (self == other)
9775 
 
9776 
class getItemCountByStatus_result:
9777 
  """
9778 
  Attributes:
9779 
   - success
9780 
  """
9781 
 
9782 
  thrift_spec = (
9783 
    (0, TType.I32, 'success', None, None, ), # 0
9784 
  )
9785 
 
9786 
  def __init__(self, success=None,):
9787 
    self.success = success
9788 
 
9789 
  def read(self, iprot):
9790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9792 
      return
9793 
    iprot.readStructBegin()
9794 
    while True:
9795 
      (fname, ftype, fid) = iprot.readFieldBegin()
9796 
      if ftype == TType.STOP:
9797 
        break
9798 
      if fid == 0:
9799 
        if ftype == TType.I32:
9800 
          self.success = iprot.readI32();
9801 
        else:
9802 
          iprot.skip(ftype)
9803 
      else:
9804 
        iprot.skip(ftype)
9805 
      iprot.readFieldEnd()
9806 
    iprot.readStructEnd()
9807 
 
9808 
  def write(self, oprot):
9809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9811 
      return
9812 
    oprot.writeStructBegin('getItemCountByStatus_result')
9813 
    if self.success is not None:
9814 
      oprot.writeFieldBegin('success', TType.I32, 0)
9815 
      oprot.writeI32(self.success)
9816 
      oprot.writeFieldEnd()
9817 
    oprot.writeFieldStop()
9818 
    oprot.writeStructEnd()
9819 
 
9820 
  def validate(self):
9821 
    return
9822 
 
9823 
 
9824 
  def __repr__(self):
9825 
    L = ['%s=%r' % (key, value)
9826 
      for key, value in self.__dict__.iteritems()]
9827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9828 
 
9829 
  def __eq__(self, other):
9830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9831 
 
9832 
  def __ne__(self, other):
9833 
    return not (self == other)
9834 
 
9835 
class getBestSellers_args:
9836 
 
9837 
  thrift_spec = (
9838 
  )
9839 
 
9840 
  def read(self, iprot):
9841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9843 
      return
9844 
    iprot.readStructBegin()
9845 
    while True:
9846 
      (fname, ftype, fid) = iprot.readFieldBegin()
9847 
      if ftype == TType.STOP:
9848 
        break
9849 
      else:
9850 
        iprot.skip(ftype)
9851 
      iprot.readFieldEnd()
9852 
    iprot.readStructEnd()
9853 
 
9854 
  def write(self, oprot):
9855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9857 
      return
9858 
    oprot.writeStructBegin('getBestSellers_args')
9859 
    oprot.writeFieldStop()
9860 
    oprot.writeStructEnd()
9861 
 
9862 
  def validate(self):
9863 
    return
9864 
 
9865 
 
9866 
  def __repr__(self):
9867 
    L = ['%s=%r' % (key, value)
9868 
      for key, value in self.__dict__.iteritems()]
9869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9870 
 
9871 
  def __eq__(self, other):
9872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9873 
 
9874 
  def __ne__(self, other):
9875 
    return not (self == other)
9876 
 
9877 
class getBestSellers_result:
9878 
  """
9879 
  Attributes:
9880 
   - success
9881 
   - isex
9882 
  """
9883 
 
9884 
  thrift_spec = (
9885 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9886 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9887 
  )
9888 
 
9889 
  def __init__(self, success=None, isex=None,):
9890 
    self.success = success
9891 
    self.isex = isex
9892 
 
9893 
  def read(self, iprot):
9894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9896 
      return
9897 
    iprot.readStructBegin()
9898 
    while True:
9899 
      (fname, ftype, fid) = iprot.readFieldBegin()
9900 
      if ftype == TType.STOP:
9901 
        break
9902 
      if fid == 0:
9903 
        if ftype == TType.LIST:
9904 
          self.success = []
8590 kshitij.so 9905 
          (_etype91, _size88) = iprot.readListBegin()
9906 
          for _i92 in xrange(_size88):
9907 
            _elem93 = Item()
9908 
            _elem93.read(iprot)
9909 
            self.success.append(_elem93)
5944 mandeep.dh 9910 
          iprot.readListEnd()
9911 
        else:
9912 
          iprot.skip(ftype)
9913 
      elif fid == 1:
9914 
        if ftype == TType.STRUCT:
9915 
          self.isex = CatalogServiceException()
9916 
          self.isex.read(iprot)
9917 
        else:
9918 
          iprot.skip(ftype)
9919 
      else:
9920 
        iprot.skip(ftype)
9921 
      iprot.readFieldEnd()
9922 
    iprot.readStructEnd()
9923 
 
9924 
  def write(self, oprot):
9925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9927 
      return
9928 
    oprot.writeStructBegin('getBestSellers_result')
9929 
    if self.success is not None:
9930 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9931 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9932 
      for iter94 in self.success:
9933 
        iter94.write(oprot)
5944 mandeep.dh 9934 
      oprot.writeListEnd()
9935 
      oprot.writeFieldEnd()
9936 
    if self.isex is not None:
9937 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9938 
      self.isex.write(oprot)
9939 
      oprot.writeFieldEnd()
9940 
    oprot.writeFieldStop()
9941 
    oprot.writeStructEnd()
9942 
 
9943 
  def validate(self):
9944 
    return
9945 
 
9946 
 
9947 
  def __repr__(self):
9948 
    L = ['%s=%r' % (key, value)
9949 
      for key, value in self.__dict__.iteritems()]
9950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9951 
 
9952 
  def __eq__(self, other):
9953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9954 
 
9955 
  def __ne__(self, other):
9956 
    return not (self == other)
9957 
 
9958 
class getBestSellersCatalogIds_args:
9959 
  """
9960 
  Attributes:
9961 
   - beginIndex
9962 
   - totalItems
9963 
   - brand
9964 
   - category
9965 
  """
9966 
 
9967 
  thrift_spec = (
9968 
    None, # 0
9969 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9970 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9971 
    (3, TType.STRING, 'brand', None, None, ), # 3
9972 
    (4, TType.I64, 'category', None, None, ), # 4
9973 
  )
9974 
 
9975 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9976 
    self.beginIndex = beginIndex
9977 
    self.totalItems = totalItems
9978 
    self.brand = brand
9979 
    self.category = category
9980 
 
9981 
  def read(self, iprot):
9982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9984 
      return
9985 
    iprot.readStructBegin()
9986 
    while True:
9987 
      (fname, ftype, fid) = iprot.readFieldBegin()
9988 
      if ftype == TType.STOP:
9989 
        break
9990 
      if fid == 1:
9991 
        if ftype == TType.I64:
9992 
          self.beginIndex = iprot.readI64();
9993 
        else:
9994 
          iprot.skip(ftype)
9995 
      elif fid == 2:
9996 
        if ftype == TType.I64:
9997 
          self.totalItems = iprot.readI64();
9998 
        else:
9999 
          iprot.skip(ftype)
10000 
      elif fid == 3:
10001 
        if ftype == TType.STRING:
10002 
          self.brand = iprot.readString();
10003 
        else:
10004 
          iprot.skip(ftype)
10005 
      elif fid == 4:
10006 
        if ftype == TType.I64:
10007 
          self.category = iprot.readI64();
10008 
        else:
10009 
          iprot.skip(ftype)
10010 
      else:
10011 
        iprot.skip(ftype)
10012 
      iprot.readFieldEnd()
10013 
    iprot.readStructEnd()
10014 
 
10015 
  def write(self, oprot):
10016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10018 
      return
10019 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
10020 
    if self.beginIndex is not None:
10021 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10022 
      oprot.writeI64(self.beginIndex)
10023 
      oprot.writeFieldEnd()
10024 
    if self.totalItems is not None:
10025 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10026 
      oprot.writeI64(self.totalItems)
10027 
      oprot.writeFieldEnd()
10028 
    if self.brand is not None:
10029 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10030 
      oprot.writeString(self.brand)
10031 
      oprot.writeFieldEnd()
10032 
    if self.category is not None:
10033 
      oprot.writeFieldBegin('category', TType.I64, 4)
10034 
      oprot.writeI64(self.category)
10035 
      oprot.writeFieldEnd()
10036 
    oprot.writeFieldStop()
10037 
    oprot.writeStructEnd()
10038 
 
10039 
  def validate(self):
10040 
    return
10041 
 
10042 
 
10043 
  def __repr__(self):
10044 
    L = ['%s=%r' % (key, value)
10045 
      for key, value in self.__dict__.iteritems()]
10046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10047 
 
10048 
  def __eq__(self, other):
10049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10050 
 
10051 
  def __ne__(self, other):
10052 
    return not (self == other)
10053 
 
10054 
class getBestSellersCatalogIds_result:
10055 
  """
10056 
  Attributes:
10057 
   - success
10058 
   - cex
10059 
  """
10060 
 
10061 
  thrift_spec = (
10062 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10063 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10064 
  )
10065 
 
10066 
  def __init__(self, success=None, cex=None,):
10067 
    self.success = success
10068 
    self.cex = cex
10069 
 
10070 
  def read(self, iprot):
10071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10073 
      return
10074 
    iprot.readStructBegin()
10075 
    while True:
10076 
      (fname, ftype, fid) = iprot.readFieldBegin()
10077 
      if ftype == TType.STOP:
10078 
        break
10079 
      if fid == 0:
10080 
        if ftype == TType.LIST:
10081 
          self.success = []
8590 kshitij.so 10082 
          (_etype98, _size95) = iprot.readListBegin()
10083 
          for _i99 in xrange(_size95):
10084 
            _elem100 = iprot.readI64();
10085 
            self.success.append(_elem100)
5944 mandeep.dh 10086 
          iprot.readListEnd()
10087 
        else:
10088 
          iprot.skip(ftype)
10089 
      elif fid == 1:
10090 
        if ftype == TType.STRUCT:
10091 
          self.cex = CatalogServiceException()
10092 
          self.cex.read(iprot)
10093 
        else:
10094 
          iprot.skip(ftype)
10095 
      else:
10096 
        iprot.skip(ftype)
10097 
      iprot.readFieldEnd()
10098 
    iprot.readStructEnd()
10099 
 
10100 
  def write(self, oprot):
10101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10103 
      return
10104 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
10105 
    if self.success is not None:
10106 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10107 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10108 
      for iter101 in self.success:
10109 
        oprot.writeI64(iter101)
5944 mandeep.dh 10110 
      oprot.writeListEnd()
10111 
      oprot.writeFieldEnd()
10112 
    if self.cex is not None:
10113 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10114 
      self.cex.write(oprot)
10115 
      oprot.writeFieldEnd()
10116 
    oprot.writeFieldStop()
10117 
    oprot.writeStructEnd()
10118 
 
10119 
  def validate(self):
10120 
    return
10121 
 
10122 
 
10123 
  def __repr__(self):
10124 
    L = ['%s=%r' % (key, value)
10125 
      for key, value in self.__dict__.iteritems()]
10126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10127 
 
10128 
  def __eq__(self, other):
10129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10130 
 
10131 
  def __ne__(self, other):
10132 
    return not (self == other)
10133 
 
10134 
class getBestSellersCount_args:
10135 
 
10136 
  thrift_spec = (
10137 
  )
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 
      else:
10149 
        iprot.skip(ftype)
10150 
      iprot.readFieldEnd()
10151 
    iprot.readStructEnd()
10152 
 
10153 
  def write(self, oprot):
10154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10156 
      return
10157 
    oprot.writeStructBegin('getBestSellersCount_args')
10158 
    oprot.writeFieldStop()
10159 
    oprot.writeStructEnd()
10160 
 
10161 
  def validate(self):
10162 
    return
10163 
 
10164 
 
10165 
  def __repr__(self):
10166 
    L = ['%s=%r' % (key, value)
10167 
      for key, value in self.__dict__.iteritems()]
10168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10169 
 
10170 
  def __eq__(self, other):
10171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10172 
 
10173 
  def __ne__(self, other):
10174 
    return not (self == other)
10175 
 
10176 
class getBestSellersCount_result:
10177 
  """
10178 
  Attributes:
10179 
   - success
10180 
   - cex
10181 
  """
10182 
 
10183 
  thrift_spec = (
10184 
    (0, TType.I64, 'success', None, None, ), # 0
10185 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10186 
  )
10187 
 
10188 
  def __init__(self, success=None, cex=None,):
10189 
    self.success = success
10190 
    self.cex = cex
10191 
 
10192 
  def read(self, iprot):
10193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10195 
      return
10196 
    iprot.readStructBegin()
10197 
    while True:
10198 
      (fname, ftype, fid) = iprot.readFieldBegin()
10199 
      if ftype == TType.STOP:
10200 
        break
10201 
      if fid == 0:
10202 
        if ftype == TType.I64:
10203 
          self.success = iprot.readI64();
10204 
        else:
10205 
          iprot.skip(ftype)
10206 
      elif fid == 1:
10207 
        if ftype == TType.STRUCT:
10208 
          self.cex = CatalogServiceException()
10209 
          self.cex.read(iprot)
10210 
        else:
10211 
          iprot.skip(ftype)
10212 
      else:
10213 
        iprot.skip(ftype)
10214 
      iprot.readFieldEnd()
10215 
    iprot.readStructEnd()
10216 
 
10217 
  def write(self, oprot):
10218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10220 
      return
10221 
    oprot.writeStructBegin('getBestSellersCount_result')
10222 
    if self.success is not None:
10223 
      oprot.writeFieldBegin('success', TType.I64, 0)
10224 
      oprot.writeI64(self.success)
10225 
      oprot.writeFieldEnd()
10226 
    if self.cex is not None:
10227 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10228 
      self.cex.write(oprot)
10229 
      oprot.writeFieldEnd()
10230 
    oprot.writeFieldStop()
10231 
    oprot.writeStructEnd()
10232 
 
10233 
  def validate(self):
10234 
    return
10235 
 
10236 
 
10237 
  def __repr__(self):
10238 
    L = ['%s=%r' % (key, value)
10239 
      for key, value in self.__dict__.iteritems()]
10240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10241 
 
10242 
  def __eq__(self, other):
10243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10244 
 
10245 
  def __ne__(self, other):
10246 
    return not (self == other)
10247 
 
10248 
class getBestDeals_args:
10249 
 
10250 
  thrift_spec = (
10251 
  )
10252 
 
10253 
  def read(self, iprot):
10254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10256 
      return
10257 
    iprot.readStructBegin()
10258 
    while True:
10259 
      (fname, ftype, fid) = iprot.readFieldBegin()
10260 
      if ftype == TType.STOP:
10261 
        break
10262 
      else:
10263 
        iprot.skip(ftype)
10264 
      iprot.readFieldEnd()
10265 
    iprot.readStructEnd()
10266 
 
10267 
  def write(self, oprot):
10268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10270 
      return
10271 
    oprot.writeStructBegin('getBestDeals_args')
10272 
    oprot.writeFieldStop()
10273 
    oprot.writeStructEnd()
10274 
 
10275 
  def validate(self):
10276 
    return
10277 
 
10278 
 
10279 
  def __repr__(self):
10280 
    L = ['%s=%r' % (key, value)
10281 
      for key, value in self.__dict__.iteritems()]
10282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10283 
 
10284 
  def __eq__(self, other):
10285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10286 
 
10287 
  def __ne__(self, other):
10288 
    return not (self == other)
10289 
 
10290 
class getBestDeals_result:
10291 
  """
10292 
  Attributes:
10293 
   - success
10294 
   - isex
10295 
  """
10296 
 
10297 
  thrift_spec = (
10298 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10299 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10300 
  )
10301 
 
10302 
  def __init__(self, success=None, isex=None,):
10303 
    self.success = success
10304 
    self.isex = isex
10305 
 
10306 
  def read(self, iprot):
10307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10309 
      return
10310 
    iprot.readStructBegin()
10311 
    while True:
10312 
      (fname, ftype, fid) = iprot.readFieldBegin()
10313 
      if ftype == TType.STOP:
10314 
        break
10315 
      if fid == 0:
10316 
        if ftype == TType.LIST:
10317 
          self.success = []
8590 kshitij.so 10318 
          (_etype105, _size102) = iprot.readListBegin()
10319 
          for _i106 in xrange(_size102):
10320 
            _elem107 = Item()
10321 
            _elem107.read(iprot)
10322 
            self.success.append(_elem107)
5944 mandeep.dh 10323 
          iprot.readListEnd()
10324 
        else:
10325 
          iprot.skip(ftype)
10326 
      elif fid == 1:
10327 
        if ftype == TType.STRUCT:
10328 
          self.isex = CatalogServiceException()
10329 
          self.isex.read(iprot)
10330 
        else:
10331 
          iprot.skip(ftype)
10332 
      else:
10333 
        iprot.skip(ftype)
10334 
      iprot.readFieldEnd()
10335 
    iprot.readStructEnd()
10336 
 
10337 
  def write(self, oprot):
10338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10340 
      return
10341 
    oprot.writeStructBegin('getBestDeals_result')
10342 
    if self.success is not None:
10343 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10344 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10345 
      for iter108 in self.success:
10346 
        iter108.write(oprot)
5944 mandeep.dh 10347 
      oprot.writeListEnd()
10348 
      oprot.writeFieldEnd()
10349 
    if self.isex is not None:
10350 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10351 
      self.isex.write(oprot)
10352 
      oprot.writeFieldEnd()
10353 
    oprot.writeFieldStop()
10354 
    oprot.writeStructEnd()
10355 
 
10356 
  def validate(self):
10357 
    return
10358 
 
10359 
 
10360 
  def __repr__(self):
10361 
    L = ['%s=%r' % (key, value)
10362 
      for key, value in self.__dict__.iteritems()]
10363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10364 
 
10365 
  def __eq__(self, other):
10366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10367 
 
10368 
  def __ne__(self, other):
10369 
    return not (self == other)
10370 
 
10371 
class getBestDealsCatalogIds_args:
10372 
  """
10373 
  Attributes:
10374 
   - beginIndex
10375 
   - totalItems
10376 
   - brand
10377 
   - category
10378 
  """
10379 
 
10380 
  thrift_spec = (
10381 
    None, # 0
10382 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10383 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10384 
    (3, TType.STRING, 'brand', None, None, ), # 3
10385 
    (4, TType.I64, 'category', None, None, ), # 4
10386 
  )
10387 
 
10388 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10389 
    self.beginIndex = beginIndex
10390 
    self.totalItems = totalItems
10391 
    self.brand = brand
10392 
    self.category = category
10393 
 
10394 
  def read(self, iprot):
10395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10397 
      return
10398 
    iprot.readStructBegin()
10399 
    while True:
10400 
      (fname, ftype, fid) = iprot.readFieldBegin()
10401 
      if ftype == TType.STOP:
10402 
        break
10403 
      if fid == 1:
10404 
        if ftype == TType.I64:
10405 
          self.beginIndex = iprot.readI64();
10406 
        else:
10407 
          iprot.skip(ftype)
10408 
      elif fid == 2:
10409 
        if ftype == TType.I64:
10410 
          self.totalItems = iprot.readI64();
10411 
        else:
10412 
          iprot.skip(ftype)
10413 
      elif fid == 3:
10414 
        if ftype == TType.STRING:
10415 
          self.brand = iprot.readString();
10416 
        else:
10417 
          iprot.skip(ftype)
10418 
      elif fid == 4:
10419 
        if ftype == TType.I64:
10420 
          self.category = iprot.readI64();
10421 
        else:
10422 
          iprot.skip(ftype)
10423 
      else:
10424 
        iprot.skip(ftype)
10425 
      iprot.readFieldEnd()
10426 
    iprot.readStructEnd()
10427 
 
10428 
  def write(self, oprot):
10429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10431 
      return
10432 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
10433 
    if self.beginIndex is not None:
10434 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10435 
      oprot.writeI64(self.beginIndex)
10436 
      oprot.writeFieldEnd()
10437 
    if self.totalItems is not None:
10438 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10439 
      oprot.writeI64(self.totalItems)
10440 
      oprot.writeFieldEnd()
10441 
    if self.brand is not None:
10442 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10443 
      oprot.writeString(self.brand)
10444 
      oprot.writeFieldEnd()
10445 
    if self.category is not None:
10446 
      oprot.writeFieldBegin('category', TType.I64, 4)
10447 
      oprot.writeI64(self.category)
10448 
      oprot.writeFieldEnd()
10449 
    oprot.writeFieldStop()
10450 
    oprot.writeStructEnd()
10451 
 
10452 
  def validate(self):
10453 
    return
10454 
 
10455 
 
10456 
  def __repr__(self):
10457 
    L = ['%s=%r' % (key, value)
10458 
      for key, value in self.__dict__.iteritems()]
10459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10460 
 
10461 
  def __eq__(self, other):
10462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10463 
 
10464 
  def __ne__(self, other):
10465 
    return not (self == other)
10466 
 
10467 
class getBestDealsCatalogIds_result:
10468 
  """
10469 
  Attributes:
10470 
   - success
10471 
   - cex
10472 
  """
10473 
 
10474 
  thrift_spec = (
10475 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10476 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10477 
  )
10478 
 
10479 
  def __init__(self, success=None, cex=None,):
10480 
    self.success = success
10481 
    self.cex = cex
10482 
 
10483 
  def read(self, iprot):
10484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10486 
      return
10487 
    iprot.readStructBegin()
10488 
    while True:
10489 
      (fname, ftype, fid) = iprot.readFieldBegin()
10490 
      if ftype == TType.STOP:
10491 
        break
10492 
      if fid == 0:
10493 
        if ftype == TType.LIST:
10494 
          self.success = []
8590 kshitij.so 10495 
          (_etype112, _size109) = iprot.readListBegin()
10496 
          for _i113 in xrange(_size109):
10497 
            _elem114 = iprot.readI64();
10498 
            self.success.append(_elem114)
5944 mandeep.dh 10499 
          iprot.readListEnd()
10500 
        else:
10501 
          iprot.skip(ftype)
10502 
      elif fid == 1:
10503 
        if ftype == TType.STRUCT:
10504 
          self.cex = CatalogServiceException()
10505 
          self.cex.read(iprot)
10506 
        else:
10507 
          iprot.skip(ftype)
10508 
      else:
10509 
        iprot.skip(ftype)
10510 
      iprot.readFieldEnd()
10511 
    iprot.readStructEnd()
10512 
 
10513 
  def write(self, oprot):
10514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10516 
      return
10517 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
10518 
    if self.success is not None:
10519 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10520 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10521 
      for iter115 in self.success:
10522 
        oprot.writeI64(iter115)
5944 mandeep.dh 10523 
      oprot.writeListEnd()
10524 
      oprot.writeFieldEnd()
10525 
    if self.cex is not None:
10526 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10527 
      self.cex.write(oprot)
10528 
      oprot.writeFieldEnd()
10529 
    oprot.writeFieldStop()
10530 
    oprot.writeStructEnd()
10531 
 
10532 
  def validate(self):
10533 
    return
10534 
 
10535 
 
10536 
  def __repr__(self):
10537 
    L = ['%s=%r' % (key, value)
10538 
      for key, value in self.__dict__.iteritems()]
10539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10540 
 
10541 
  def __eq__(self, other):
10542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10543 
 
10544 
  def __ne__(self, other):
10545 
    return not (self == other)
10546 
 
10547 
class getBestDealsCount_args:
10548 
 
10549 
  thrift_spec = (
10550 
  )
10551 
 
10552 
  def read(self, iprot):
10553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10555 
      return
10556 
    iprot.readStructBegin()
10557 
    while True:
10558 
      (fname, ftype, fid) = iprot.readFieldBegin()
10559 
      if ftype == TType.STOP:
10560 
        break
10561 
      else:
10562 
        iprot.skip(ftype)
10563 
      iprot.readFieldEnd()
10564 
    iprot.readStructEnd()
10565 
 
10566 
  def write(self, oprot):
10567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10569 
      return
10570 
    oprot.writeStructBegin('getBestDealsCount_args')
10571 
    oprot.writeFieldStop()
10572 
    oprot.writeStructEnd()
10573 
 
10574 
  def validate(self):
10575 
    return
10576 
 
10577 
 
10578 
  def __repr__(self):
10579 
    L = ['%s=%r' % (key, value)
10580 
      for key, value in self.__dict__.iteritems()]
10581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10582 
 
10583 
  def __eq__(self, other):
10584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10585 
 
10586 
  def __ne__(self, other):
10587 
    return not (self == other)
10588 
 
10589 
class getBestDealsCount_result:
10590 
  """
10591 
  Attributes:
10592 
   - success
10593 
   - cex
10594 
  """
10595 
 
10596 
  thrift_spec = (
10597 
    (0, TType.I64, 'success', None, None, ), # 0
10598 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10599 
  )
10600 
 
10601 
  def __init__(self, success=None, cex=None,):
10602 
    self.success = success
10603 
    self.cex = cex
10604 
 
10605 
  def read(self, iprot):
10606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10608 
      return
10609 
    iprot.readStructBegin()
10610 
    while True:
10611 
      (fname, ftype, fid) = iprot.readFieldBegin()
10612 
      if ftype == TType.STOP:
10613 
        break
10614 
      if fid == 0:
10615 
        if ftype == TType.I64:
10616 
          self.success = iprot.readI64();
10617 
        else:
10618 
          iprot.skip(ftype)
10619 
      elif fid == 1:
10620 
        if ftype == TType.STRUCT:
10621 
          self.cex = CatalogServiceException()
10622 
          self.cex.read(iprot)
10623 
        else:
10624 
          iprot.skip(ftype)
10625 
      else:
10626 
        iprot.skip(ftype)
10627 
      iprot.readFieldEnd()
10628 
    iprot.readStructEnd()
10629 
 
10630 
  def write(self, oprot):
10631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10633 
      return
10634 
    oprot.writeStructBegin('getBestDealsCount_result')
10635 
    if self.success is not None:
10636 
      oprot.writeFieldBegin('success', TType.I64, 0)
10637 
      oprot.writeI64(self.success)
10638 
      oprot.writeFieldEnd()
10639 
    if self.cex is not None:
10640 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10641 
      self.cex.write(oprot)
10642 
      oprot.writeFieldEnd()
10643 
    oprot.writeFieldStop()
10644 
    oprot.writeStructEnd()
10645 
 
10646 
  def validate(self):
10647 
    return
10648 
 
10649 
 
10650 
  def __repr__(self):
10651 
    L = ['%s=%r' % (key, value)
10652 
      for key, value in self.__dict__.iteritems()]
10653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10654 
 
10655 
  def __eq__(self, other):
10656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10657 
 
10658 
  def __ne__(self, other):
10659 
    return not (self == other)
10660 
 
10661 
class getComingSoon_args:
10662 
 
10663 
  thrift_spec = (
10664 
  )
10665 
 
10666 
  def read(self, iprot):
10667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10669 
      return
10670 
    iprot.readStructBegin()
10671 
    while True:
10672 
      (fname, ftype, fid) = iprot.readFieldBegin()
10673 
      if ftype == TType.STOP:
10674 
        break
10675 
      else:
10676 
        iprot.skip(ftype)
10677 
      iprot.readFieldEnd()
10678 
    iprot.readStructEnd()
10679 
 
10680 
  def write(self, oprot):
10681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10683 
      return
10684 
    oprot.writeStructBegin('getComingSoon_args')
10685 
    oprot.writeFieldStop()
10686 
    oprot.writeStructEnd()
10687 
 
10688 
  def validate(self):
10689 
    return
10690 
 
10691 
 
10692 
  def __repr__(self):
10693 
    L = ['%s=%r' % (key, value)
10694 
      for key, value in self.__dict__.iteritems()]
10695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10696 
 
10697 
  def __eq__(self, other):
10698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10699 
 
10700 
  def __ne__(self, other):
10701 
    return not (self == other)
10702 
 
10703 
class getComingSoon_result:
10704 
  """
10705 
  Attributes:
10706 
   - success
10707 
   - isex
10708 
  """
10709 
 
10710 
  thrift_spec = (
10711 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10712 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10713 
  )
10714 
 
10715 
  def __init__(self, success=None, isex=None,):
10716 
    self.success = success
10717 
    self.isex = isex
10718 
 
10719 
  def read(self, iprot):
10720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10722 
      return
10723 
    iprot.readStructBegin()
10724 
    while True:
10725 
      (fname, ftype, fid) = iprot.readFieldBegin()
10726 
      if ftype == TType.STOP:
10727 
        break
10728 
      if fid == 0:
10729 
        if ftype == TType.LIST:
10730 
          self.success = []
8590 kshitij.so 10731 
          (_etype119, _size116) = iprot.readListBegin()
10732 
          for _i120 in xrange(_size116):
10733 
            _elem121 = Item()
10734 
            _elem121.read(iprot)
10735 
            self.success.append(_elem121)
5944 mandeep.dh 10736 
          iprot.readListEnd()
10737 
        else:
10738 
          iprot.skip(ftype)
10739 
      elif fid == 1:
10740 
        if ftype == TType.STRUCT:
10741 
          self.isex = CatalogServiceException()
10742 
          self.isex.read(iprot)
10743 
        else:
10744 
          iprot.skip(ftype)
10745 
      else:
10746 
        iprot.skip(ftype)
10747 
      iprot.readFieldEnd()
10748 
    iprot.readStructEnd()
10749 
 
10750 
  def write(self, oprot):
10751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10753 
      return
10754 
    oprot.writeStructBegin('getComingSoon_result')
10755 
    if self.success is not None:
10756 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10757 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10758 
      for iter122 in self.success:
10759 
        iter122.write(oprot)
5944 mandeep.dh 10760 
      oprot.writeListEnd()
10761 
      oprot.writeFieldEnd()
10762 
    if self.isex is not None:
10763 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10764 
      self.isex.write(oprot)
10765 
      oprot.writeFieldEnd()
10766 
    oprot.writeFieldStop()
10767 
    oprot.writeStructEnd()
10768 
 
10769 
  def validate(self):
10770 
    return
10771 
 
10772 
 
10773 
  def __repr__(self):
10774 
    L = ['%s=%r' % (key, value)
10775 
      for key, value in self.__dict__.iteritems()]
10776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10777 
 
10778 
  def __eq__(self, other):
10779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10780 
 
10781 
  def __ne__(self, other):
10782 
    return not (self == other)
10783 
 
10784 
class getComingSoonCatalogIds_args:
10785 
  """
10786 
  Attributes:
10787 
   - beginIndex
10788 
   - totalItems
10789 
   - brand
10790 
   - category
10791 
  """
10792 
 
10793 
  thrift_spec = (
10794 
    None, # 0
10795 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10796 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10797 
    (3, TType.STRING, 'brand', None, None, ), # 3
10798 
    (4, TType.I64, 'category', None, None, ), # 4
10799 
  )
10800 
 
10801 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10802 
    self.beginIndex = beginIndex
10803 
    self.totalItems = totalItems
10804 
    self.brand = brand
10805 
    self.category = category
10806 
 
10807 
  def read(self, iprot):
10808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10810 
      return
10811 
    iprot.readStructBegin()
10812 
    while True:
10813 
      (fname, ftype, fid) = iprot.readFieldBegin()
10814 
      if ftype == TType.STOP:
10815 
        break
10816 
      if fid == 1:
10817 
        if ftype == TType.I64:
10818 
          self.beginIndex = iprot.readI64();
10819 
        else:
10820 
          iprot.skip(ftype)
10821 
      elif fid == 2:
10822 
        if ftype == TType.I64:
10823 
          self.totalItems = iprot.readI64();
10824 
        else:
10825 
          iprot.skip(ftype)
10826 
      elif fid == 3:
10827 
        if ftype == TType.STRING:
10828 
          self.brand = iprot.readString();
10829 
        else:
10830 
          iprot.skip(ftype)
10831 
      elif fid == 4:
10832 
        if ftype == TType.I64:
10833 
          self.category = iprot.readI64();
10834 
        else:
10835 
          iprot.skip(ftype)
10836 
      else:
10837 
        iprot.skip(ftype)
10838 
      iprot.readFieldEnd()
10839 
    iprot.readStructEnd()
10840 
 
10841 
  def write(self, oprot):
10842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10844 
      return
10845 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
10846 
    if self.beginIndex is not None:
10847 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10848 
      oprot.writeI64(self.beginIndex)
10849 
      oprot.writeFieldEnd()
10850 
    if self.totalItems is not None:
10851 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10852 
      oprot.writeI64(self.totalItems)
10853 
      oprot.writeFieldEnd()
10854 
    if self.brand is not None:
10855 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10856 
      oprot.writeString(self.brand)
10857 
      oprot.writeFieldEnd()
10858 
    if self.category is not None:
10859 
      oprot.writeFieldBegin('category', TType.I64, 4)
10860 
      oprot.writeI64(self.category)
10861 
      oprot.writeFieldEnd()
10862 
    oprot.writeFieldStop()
10863 
    oprot.writeStructEnd()
10864 
 
10865 
  def validate(self):
10866 
    return
10867 
 
10868 
 
10869 
  def __repr__(self):
10870 
    L = ['%s=%r' % (key, value)
10871 
      for key, value in self.__dict__.iteritems()]
10872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10873 
 
10874 
  def __eq__(self, other):
10875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10876 
 
10877 
  def __ne__(self, other):
10878 
    return not (self == other)
10879 
 
10880 
class getComingSoonCatalogIds_result:
10881 
  """
10882 
  Attributes:
10883 
   - success
10884 
   - cex
10885 
  """
10886 
 
10887 
  thrift_spec = (
10888 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10889 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10890 
  )
10891 
 
10892 
  def __init__(self, success=None, cex=None,):
10893 
    self.success = success
10894 
    self.cex = cex
10895 
 
10896 
  def read(self, iprot):
10897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10899 
      return
10900 
    iprot.readStructBegin()
10901 
    while True:
10902 
      (fname, ftype, fid) = iprot.readFieldBegin()
10903 
      if ftype == TType.STOP:
10904 
        break
10905 
      if fid == 0:
10906 
        if ftype == TType.LIST:
10907 
          self.success = []
8590 kshitij.so 10908 
          (_etype126, _size123) = iprot.readListBegin()
10909 
          for _i127 in xrange(_size123):
10910 
            _elem128 = iprot.readI64();
10911 
            self.success.append(_elem128)
5944 mandeep.dh 10912 
          iprot.readListEnd()
10913 
        else:
10914 
          iprot.skip(ftype)
10915 
      elif fid == 1:
10916 
        if ftype == TType.STRUCT:
10917 
          self.cex = CatalogServiceException()
10918 
          self.cex.read(iprot)
10919 
        else:
10920 
          iprot.skip(ftype)
10921 
      else:
10922 
        iprot.skip(ftype)
10923 
      iprot.readFieldEnd()
10924 
    iprot.readStructEnd()
10925 
 
10926 
  def write(self, oprot):
10927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10929 
      return
10930 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
10931 
    if self.success is not None:
10932 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10933 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10934 
      for iter129 in self.success:
10935 
        oprot.writeI64(iter129)
5944 mandeep.dh 10936 
      oprot.writeListEnd()
10937 
      oprot.writeFieldEnd()
10938 
    if self.cex is not None:
10939 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10940 
      self.cex.write(oprot)
10941 
      oprot.writeFieldEnd()
10942 
    oprot.writeFieldStop()
10943 
    oprot.writeStructEnd()
10944 
 
10945 
  def validate(self):
10946 
    return
10947 
 
10948 
 
10949 
  def __repr__(self):
10950 
    L = ['%s=%r' % (key, value)
10951 
      for key, value in self.__dict__.iteritems()]
10952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10953 
 
10954 
  def __eq__(self, other):
10955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10956 
 
10957 
  def __ne__(self, other):
10958 
    return not (self == other)
10959 
 
10960 
class getComingSoonCount_args:
10961 
 
10962 
  thrift_spec = (
10963 
  )
10964 
 
10965 
  def read(self, iprot):
10966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10968 
      return
10969 
    iprot.readStructBegin()
10970 
    while True:
10971 
      (fname, ftype, fid) = iprot.readFieldBegin()
10972 
      if ftype == TType.STOP:
10973 
        break
10974 
      else:
10975 
        iprot.skip(ftype)
10976 
      iprot.readFieldEnd()
10977 
    iprot.readStructEnd()
10978 
 
10979 
  def write(self, oprot):
10980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10982 
      return
10983 
    oprot.writeStructBegin('getComingSoonCount_args')
10984 
    oprot.writeFieldStop()
10985 
    oprot.writeStructEnd()
10986 
 
10987 
  def validate(self):
10988 
    return
10989 
 
10990 
 
10991 
  def __repr__(self):
10992 
    L = ['%s=%r' % (key, value)
10993 
      for key, value in self.__dict__.iteritems()]
10994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10995 
 
10996 
  def __eq__(self, other):
10997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10998 
 
10999 
  def __ne__(self, other):
11000 
    return not (self == other)
11001 
 
11002 
class getComingSoonCount_result:
11003 
  """
11004 
  Attributes:
11005 
   - success
11006 
   - cex
11007 
  """
11008 
 
11009 
  thrift_spec = (
11010 
    (0, TType.I64, 'success', None, None, ), # 0
11011 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11012 
  )
11013 
 
11014 
  def __init__(self, success=None, cex=None,):
11015 
    self.success = success
11016 
    self.cex = cex
11017 
 
11018 
  def read(self, iprot):
11019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11021 
      return
11022 
    iprot.readStructBegin()
11023 
    while True:
11024 
      (fname, ftype, fid) = iprot.readFieldBegin()
11025 
      if ftype == TType.STOP:
11026 
        break
11027 
      if fid == 0:
11028 
        if ftype == TType.I64:
11029 
          self.success = iprot.readI64();
11030 
        else:
11031 
          iprot.skip(ftype)
11032 
      elif fid == 1:
11033 
        if ftype == TType.STRUCT:
11034 
          self.cex = CatalogServiceException()
11035 
          self.cex.read(iprot)
11036 
        else:
11037 
          iprot.skip(ftype)
11038 
      else:
11039 
        iprot.skip(ftype)
11040 
      iprot.readFieldEnd()
11041 
    iprot.readStructEnd()
11042 
 
11043 
  def write(self, oprot):
11044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11046 
      return
11047 
    oprot.writeStructBegin('getComingSoonCount_result')
11048 
    if self.success is not None:
11049 
      oprot.writeFieldBegin('success', TType.I64, 0)
11050 
      oprot.writeI64(self.success)
11051 
      oprot.writeFieldEnd()
11052 
    if self.cex is not None:
11053 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11054 
      self.cex.write(oprot)
11055 
      oprot.writeFieldEnd()
11056 
    oprot.writeFieldStop()
11057 
    oprot.writeStructEnd()
11058 
 
11059 
  def validate(self):
11060 
    return
11061 
 
11062 
 
11063 
  def __repr__(self):
11064 
    L = ['%s=%r' % (key, value)
11065 
      for key, value in self.__dict__.iteritems()]
11066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11067 
 
11068 
  def __eq__(self, other):
11069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11070 
 
11071 
  def __ne__(self, other):
11072 
    return not (self == other)
11073 
 
11074 
class getLatestArrivals_args:
11075 
 
11076 
  thrift_spec = (
11077 
  )
11078 
 
11079 
  def read(self, iprot):
11080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11082 
      return
11083 
    iprot.readStructBegin()
11084 
    while True:
11085 
      (fname, ftype, fid) = iprot.readFieldBegin()
11086 
      if ftype == TType.STOP:
11087 
        break
11088 
      else:
11089 
        iprot.skip(ftype)
11090 
      iprot.readFieldEnd()
11091 
    iprot.readStructEnd()
11092 
 
11093 
  def write(self, oprot):
11094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11096 
      return
11097 
    oprot.writeStructBegin('getLatestArrivals_args')
11098 
    oprot.writeFieldStop()
11099 
    oprot.writeStructEnd()
11100 
 
11101 
  def validate(self):
11102 
    return
11103 
 
11104 
 
11105 
  def __repr__(self):
11106 
    L = ['%s=%r' % (key, value)
11107 
      for key, value in self.__dict__.iteritems()]
11108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11109 
 
11110 
  def __eq__(self, other):
11111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11112 
 
11113 
  def __ne__(self, other):
11114 
    return not (self == other)
11115 
 
11116 
class getLatestArrivals_result:
11117 
  """
11118 
  Attributes:
11119 
   - success
11120 
   - isex
11121 
  """
11122 
 
11123 
  thrift_spec = (
11124 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11125 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11126 
  )
11127 
 
11128 
  def __init__(self, success=None, isex=None,):
11129 
    self.success = success
11130 
    self.isex = isex
11131 
 
11132 
  def read(self, iprot):
11133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11135 
      return
11136 
    iprot.readStructBegin()
11137 
    while True:
11138 
      (fname, ftype, fid) = iprot.readFieldBegin()
11139 
      if ftype == TType.STOP:
11140 
        break
11141 
      if fid == 0:
11142 
        if ftype == TType.LIST:
11143 
          self.success = []
8590 kshitij.so 11144 
          (_etype133, _size130) = iprot.readListBegin()
11145 
          for _i134 in xrange(_size130):
11146 
            _elem135 = Item()
11147 
            _elem135.read(iprot)
11148 
            self.success.append(_elem135)
5944 mandeep.dh 11149 
          iprot.readListEnd()
11150 
        else:
11151 
          iprot.skip(ftype)
11152 
      elif fid == 1:
11153 
        if ftype == TType.STRUCT:
11154 
          self.isex = CatalogServiceException()
11155 
          self.isex.read(iprot)
11156 
        else:
11157 
          iprot.skip(ftype)
11158 
      else:
11159 
        iprot.skip(ftype)
11160 
      iprot.readFieldEnd()
11161 
    iprot.readStructEnd()
11162 
 
11163 
  def write(self, oprot):
11164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11166 
      return
11167 
    oprot.writeStructBegin('getLatestArrivals_result')
11168 
    if self.success is not None:
11169 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11170 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11171 
      for iter136 in self.success:
11172 
        iter136.write(oprot)
5944 mandeep.dh 11173 
      oprot.writeListEnd()
11174 
      oprot.writeFieldEnd()
11175 
    if self.isex is not None:
11176 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11177 
      self.isex.write(oprot)
11178 
      oprot.writeFieldEnd()
11179 
    oprot.writeFieldStop()
11180 
    oprot.writeStructEnd()
11181 
 
11182 
  def validate(self):
11183 
    return
11184 
 
11185 
 
11186 
  def __repr__(self):
11187 
    L = ['%s=%r' % (key, value)
11188 
      for key, value in self.__dict__.iteritems()]
11189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11190 
 
11191 
  def __eq__(self, other):
11192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11193 
 
11194 
  def __ne__(self, other):
11195 
    return not (self == other)
11196 
 
11197 
class getLatestArrivalsCatalogIds_args:
11198 
  """
11199 
  Attributes:
11200 
   - beginIndex
11201 
   - totalItems
11202 
   - brand
11203 
   - categories
11204 
  """
11205 
 
11206 
  thrift_spec = (
11207 
    None, # 0
11208 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11209 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11210 
    (3, TType.STRING, 'brand', None, None, ), # 3
11211 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
11212 
  )
11213 
 
11214 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
11215 
    self.beginIndex = beginIndex
11216 
    self.totalItems = totalItems
11217 
    self.brand = brand
11218 
    self.categories = categories
11219 
 
11220 
  def read(self, iprot):
11221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11223 
      return
11224 
    iprot.readStructBegin()
11225 
    while True:
11226 
      (fname, ftype, fid) = iprot.readFieldBegin()
11227 
      if ftype == TType.STOP:
11228 
        break
11229 
      if fid == 1:
11230 
        if ftype == TType.I64:
11231 
          self.beginIndex = iprot.readI64();
11232 
        else:
11233 
          iprot.skip(ftype)
11234 
      elif fid == 2:
11235 
        if ftype == TType.I64:
11236 
          self.totalItems = iprot.readI64();
11237 
        else:
11238 
          iprot.skip(ftype)
11239 
      elif fid == 3:
11240 
        if ftype == TType.STRING:
11241 
          self.brand = iprot.readString();
11242 
        else:
11243 
          iprot.skip(ftype)
11244 
      elif fid == 4:
11245 
        if ftype == TType.LIST:
11246 
          self.categories = []
8590 kshitij.so 11247 
          (_etype140, _size137) = iprot.readListBegin()
11248 
          for _i141 in xrange(_size137):
11249 
            _elem142 = iprot.readI64();
11250 
            self.categories.append(_elem142)
5944 mandeep.dh 11251 
          iprot.readListEnd()
11252 
        else:
11253 
          iprot.skip(ftype)
11254 
      else:
11255 
        iprot.skip(ftype)
11256 
      iprot.readFieldEnd()
11257 
    iprot.readStructEnd()
11258 
 
11259 
  def write(self, oprot):
11260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11262 
      return
11263 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
11264 
    if self.beginIndex is not None:
11265 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11266 
      oprot.writeI64(self.beginIndex)
11267 
      oprot.writeFieldEnd()
11268 
    if self.totalItems is not None:
11269 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11270 
      oprot.writeI64(self.totalItems)
11271 
      oprot.writeFieldEnd()
11272 
    if self.brand is not None:
11273 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11274 
      oprot.writeString(self.brand)
11275 
      oprot.writeFieldEnd()
11276 
    if self.categories is not None:
11277 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
11278 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 11279 
      for iter143 in self.categories:
11280 
        oprot.writeI64(iter143)
5944 mandeep.dh 11281 
      oprot.writeListEnd()
11282 
      oprot.writeFieldEnd()
11283 
    oprot.writeFieldStop()
11284 
    oprot.writeStructEnd()
11285 
 
11286 
  def validate(self):
11287 
    return
11288 
 
11289 
 
11290 
  def __repr__(self):
11291 
    L = ['%s=%r' % (key, value)
11292 
      for key, value in self.__dict__.iteritems()]
11293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11294 
 
11295 
  def __eq__(self, other):
11296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11297 
 
11298 
  def __ne__(self, other):
11299 
    return not (self == other)
11300 
 
11301 
class getLatestArrivalsCatalogIds_result:
11302 
  """
11303 
  Attributes:
11304 
   - success
11305 
   - cex
11306 
  """
11307 
 
11308 
  thrift_spec = (
11309 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11310 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11311 
  )
11312 
 
11313 
  def __init__(self, success=None, cex=None,):
11314 
    self.success = success
11315 
    self.cex = cex
11316 
 
11317 
  def read(self, iprot):
11318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11320 
      return
11321 
    iprot.readStructBegin()
11322 
    while True:
11323 
      (fname, ftype, fid) = iprot.readFieldBegin()
11324 
      if ftype == TType.STOP:
11325 
        break
11326 
      if fid == 0:
11327 
        if ftype == TType.LIST:
11328 
          self.success = []
8590 kshitij.so 11329 
          (_etype147, _size144) = iprot.readListBegin()
11330 
          for _i148 in xrange(_size144):
11331 
            _elem149 = iprot.readI64();
11332 
            self.success.append(_elem149)
5944 mandeep.dh 11333 
          iprot.readListEnd()
11334 
        else:
11335 
          iprot.skip(ftype)
11336 
      elif fid == 1:
11337 
        if ftype == TType.STRUCT:
11338 
          self.cex = CatalogServiceException()
11339 
          self.cex.read(iprot)
11340 
        else:
11341 
          iprot.skip(ftype)
11342 
      else:
11343 
        iprot.skip(ftype)
11344 
      iprot.readFieldEnd()
11345 
    iprot.readStructEnd()
11346 
 
11347 
  def write(self, oprot):
11348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11350 
      return
11351 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
11352 
    if self.success is not None:
11353 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11354 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11355 
      for iter150 in self.success:
11356 
        oprot.writeI64(iter150)
5944 mandeep.dh 11357 
      oprot.writeListEnd()
11358 
      oprot.writeFieldEnd()
11359 
    if self.cex is not None:
11360 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11361 
      self.cex.write(oprot)
11362 
      oprot.writeFieldEnd()
11363 
    oprot.writeFieldStop()
11364 
    oprot.writeStructEnd()
11365 
 
11366 
  def validate(self):
11367 
    return
11368 
 
11369 
 
11370 
  def __repr__(self):
11371 
    L = ['%s=%r' % (key, value)
11372 
      for key, value in self.__dict__.iteritems()]
11373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11374 
 
11375 
  def __eq__(self, other):
11376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11377 
 
11378 
  def __ne__(self, other):
11379 
    return not (self == other)
11380 
 
11381 
class getLatestArrivalsCount_args:
11382 
 
11383 
  thrift_spec = (
11384 
  )
11385 
 
11386 
  def read(self, iprot):
11387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11389 
      return
11390 
    iprot.readStructBegin()
11391 
    while True:
11392 
      (fname, ftype, fid) = iprot.readFieldBegin()
11393 
      if ftype == TType.STOP:
11394 
        break
11395 
      else:
11396 
        iprot.skip(ftype)
11397 
      iprot.readFieldEnd()
11398 
    iprot.readStructEnd()
11399 
 
11400 
  def write(self, oprot):
11401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11403 
      return
11404 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
11405 
    oprot.writeFieldStop()
11406 
    oprot.writeStructEnd()
11407 
 
11408 
  def validate(self):
11409 
    return
11410 
 
11411 
 
11412 
  def __repr__(self):
11413 
    L = ['%s=%r' % (key, value)
11414 
      for key, value in self.__dict__.iteritems()]
11415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11416 
 
11417 
  def __eq__(self, other):
11418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11419 
 
11420 
  def __ne__(self, other):
11421 
    return not (self == other)
11422 
 
11423 
class getLatestArrivalsCount_result:
11424 
  """
11425 
  Attributes:
11426 
   - success
11427 
   - cex
11428 
  """
11429 
 
11430 
  thrift_spec = (
11431 
    (0, TType.I64, 'success', None, None, ), # 0
11432 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11433 
  )
11434 
 
11435 
  def __init__(self, success=None, cex=None,):
11436 
    self.success = success
11437 
    self.cex = cex
11438 
 
11439 
  def read(self, iprot):
11440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11442 
      return
11443 
    iprot.readStructBegin()
11444 
    while True:
11445 
      (fname, ftype, fid) = iprot.readFieldBegin()
11446 
      if ftype == TType.STOP:
11447 
        break
11448 
      if fid == 0:
11449 
        if ftype == TType.I64:
11450 
          self.success = iprot.readI64();
11451 
        else:
11452 
          iprot.skip(ftype)
11453 
      elif fid == 1:
11454 
        if ftype == TType.STRUCT:
11455 
          self.cex = CatalogServiceException()
11456 
          self.cex.read(iprot)
11457 
        else:
11458 
          iprot.skip(ftype)
11459 
      else:
11460 
        iprot.skip(ftype)
11461 
      iprot.readFieldEnd()
11462 
    iprot.readStructEnd()
11463 
 
11464 
  def write(self, oprot):
11465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11467 
      return
11468 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
11469 
    if self.success is not None:
11470 
      oprot.writeFieldBegin('success', TType.I64, 0)
11471 
      oprot.writeI64(self.success)
11472 
      oprot.writeFieldEnd()
11473 
    if self.cex is not None:
11474 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11475 
      self.cex.write(oprot)
11476 
      oprot.writeFieldEnd()
11477 
    oprot.writeFieldStop()
11478 
    oprot.writeStructEnd()
11479 
 
11480 
  def validate(self):
11481 
    return
11482 
 
11483 
 
11484 
  def __repr__(self):
11485 
    L = ['%s=%r' % (key, value)
11486 
      for key, value in self.__dict__.iteritems()]
11487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11488 
 
11489 
  def __eq__(self, other):
11490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11491 
 
11492 
  def __ne__(self, other):
11493 
    return not (self == other)
11494 
 
11495 
class generateNewEntityID_args:
11496 
 
11497 
  thrift_spec = (
11498 
  )
11499 
 
11500 
  def read(self, iprot):
11501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11503 
      return
11504 
    iprot.readStructBegin()
11505 
    while True:
11506 
      (fname, ftype, fid) = iprot.readFieldBegin()
11507 
      if ftype == TType.STOP:
11508 
        break
11509 
      else:
11510 
        iprot.skip(ftype)
11511 
      iprot.readFieldEnd()
11512 
    iprot.readStructEnd()
11513 
 
11514 
  def write(self, oprot):
11515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11517 
      return
11518 
    oprot.writeStructBegin('generateNewEntityID_args')
11519 
    oprot.writeFieldStop()
11520 
    oprot.writeStructEnd()
11521 
 
11522 
  def validate(self):
11523 
    return
11524 
 
11525 
 
11526 
  def __repr__(self):
11527 
    L = ['%s=%r' % (key, value)
11528 
      for key, value in self.__dict__.iteritems()]
11529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11530 
 
11531 
  def __eq__(self, other):
11532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11533 
 
11534 
  def __ne__(self, other):
11535 
    return not (self == other)
11536 
 
11537 
class generateNewEntityID_result:
11538 
  """
11539 
  Attributes:
11540 
   - success
11541 
  """
11542 
 
11543 
  thrift_spec = (
11544 
    (0, TType.I64, 'success', None, None, ), # 0
11545 
  )
11546 
 
11547 
  def __init__(self, success=None,):
11548 
    self.success = success
11549 
 
11550 
  def read(self, iprot):
11551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11553 
      return
11554 
    iprot.readStructBegin()
11555 
    while True:
11556 
      (fname, ftype, fid) = iprot.readFieldBegin()
11557 
      if ftype == TType.STOP:
11558 
        break
11559 
      if fid == 0:
11560 
        if ftype == TType.I64:
11561 
          self.success = iprot.readI64();
11562 
        else:
11563 
          iprot.skip(ftype)
11564 
      else:
11565 
        iprot.skip(ftype)
11566 
      iprot.readFieldEnd()
11567 
    iprot.readStructEnd()
11568 
 
11569 
  def write(self, oprot):
11570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11572 
      return
11573 
    oprot.writeStructBegin('generateNewEntityID_result')
11574 
    if self.success is not None:
11575 
      oprot.writeFieldBegin('success', TType.I64, 0)
11576 
      oprot.writeI64(self.success)
11577 
      oprot.writeFieldEnd()
11578 
    oprot.writeFieldStop()
11579 
    oprot.writeStructEnd()
11580 
 
11581 
  def validate(self):
11582 
    return
11583 
 
11584 
 
11585 
  def __repr__(self):
11586 
    L = ['%s=%r' % (key, value)
11587 
      for key, value in self.__dict__.iteritems()]
11588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11589 
 
11590 
  def __eq__(self, other):
11591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11592 
 
11593 
  def __ne__(self, other):
11594 
    return not (self == other)
11595 
 
11596 
class addCategory_args:
11597 
  """
11598 
  Attributes:
11599 
   - category
11600 
  """
11601 
 
11602 
  thrift_spec = (
11603 
    None, # 0
11604 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
11605 
  )
11606 
 
11607 
  def __init__(self, category=None,):
11608 
    self.category = category
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.STRUCT:
11621 
          self.category = Category()
11622 
          self.category.read(iprot)
11623 
        else:
11624 
          iprot.skip(ftype)
11625 
      else:
11626 
        iprot.skip(ftype)
11627 
      iprot.readFieldEnd()
11628 
    iprot.readStructEnd()
11629 
 
11630 
  def write(self, oprot):
11631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11633 
      return
11634 
    oprot.writeStructBegin('addCategory_args')
11635 
    if self.category is not None:
11636 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
11637 
      self.category.write(oprot)
11638 
      oprot.writeFieldEnd()
11639 
    oprot.writeFieldStop()
11640 
    oprot.writeStructEnd()
11641 
 
11642 
  def validate(self):
11643 
    return
11644 
 
11645 
 
11646 
  def __repr__(self):
11647 
    L = ['%s=%r' % (key, value)
11648 
      for key, value in self.__dict__.iteritems()]
11649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11650 
 
11651 
  def __eq__(self, other):
11652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11653 
 
11654 
  def __ne__(self, other):
11655 
    return not (self == other)
11656 
 
11657 
class addCategory_result:
11658 
  """
11659 
  Attributes:
11660 
   - success
11661 
  """
11662 
 
11663 
  thrift_spec = (
11664 
    (0, TType.BOOL, 'success', None, None, ), # 0
11665 
  )
11666 
 
11667 
  def __init__(self, success=None,):
11668 
    self.success = success
11669 
 
11670 
  def read(self, iprot):
11671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11673 
      return
11674 
    iprot.readStructBegin()
11675 
    while True:
11676 
      (fname, ftype, fid) = iprot.readFieldBegin()
11677 
      if ftype == TType.STOP:
11678 
        break
11679 
      if fid == 0:
11680 
        if ftype == TType.BOOL:
11681 
          self.success = iprot.readBool();
11682 
        else:
11683 
          iprot.skip(ftype)
11684 
      else:
11685 
        iprot.skip(ftype)
11686 
      iprot.readFieldEnd()
11687 
    iprot.readStructEnd()
11688 
 
11689 
  def write(self, oprot):
11690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11692 
      return
11693 
    oprot.writeStructBegin('addCategory_result')
11694 
    if self.success is not None:
11695 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11696 
      oprot.writeBool(self.success)
11697 
      oprot.writeFieldEnd()
11698 
    oprot.writeFieldStop()
11699 
    oprot.writeStructEnd()
11700 
 
11701 
  def validate(self):
11702 
    return
11703 
 
11704 
 
11705 
  def __repr__(self):
11706 
    L = ['%s=%r' % (key, value)
11707 
      for key, value in self.__dict__.iteritems()]
11708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11709 
 
11710 
  def __eq__(self, other):
11711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11712 
 
11713 
  def __ne__(self, other):
11714 
    return not (self == other)
11715 
 
11716 
class getCategory_args:
11717 
  """
11718 
  Attributes:
11719 
   - id
11720 
  """
11721 
 
11722 
  thrift_spec = (
11723 
    None, # 0
11724 
    (1, TType.I64, 'id', None, None, ), # 1
11725 
  )
11726 
 
11727 
  def __init__(self, id=None,):
11728 
    self.id = id
11729 
 
11730 
  def read(self, iprot):
11731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11733 
      return
11734 
    iprot.readStructBegin()
11735 
    while True:
11736 
      (fname, ftype, fid) = iprot.readFieldBegin()
11737 
      if ftype == TType.STOP:
11738 
        break
11739 
      if fid == 1:
11740 
        if ftype == TType.I64:
11741 
          self.id = iprot.readI64();
11742 
        else:
11743 
          iprot.skip(ftype)
11744 
      else:
11745 
        iprot.skip(ftype)
11746 
      iprot.readFieldEnd()
11747 
    iprot.readStructEnd()
11748 
 
11749 
  def write(self, oprot):
11750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11752 
      return
11753 
    oprot.writeStructBegin('getCategory_args')
11754 
    if self.id is not None:
11755 
      oprot.writeFieldBegin('id', TType.I64, 1)
11756 
      oprot.writeI64(self.id)
11757 
      oprot.writeFieldEnd()
11758 
    oprot.writeFieldStop()
11759 
    oprot.writeStructEnd()
11760 
 
11761 
  def validate(self):
11762 
    return
11763 
 
11764 
 
11765 
  def __repr__(self):
11766 
    L = ['%s=%r' % (key, value)
11767 
      for key, value in self.__dict__.iteritems()]
11768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11769 
 
11770 
  def __eq__(self, other):
11771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11772 
 
11773 
  def __ne__(self, other):
11774 
    return not (self == other)
11775 
 
11776 
class getCategory_result:
11777 
  """
11778 
  Attributes:
11779 
   - success
11780 
  """
11781 
 
11782 
  thrift_spec = (
11783 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
11784 
  )
11785 
 
11786 
  def __init__(self, success=None,):
11787 
    self.success = success
11788 
 
11789 
  def read(self, iprot):
11790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11792 
      return
11793 
    iprot.readStructBegin()
11794 
    while True:
11795 
      (fname, ftype, fid) = iprot.readFieldBegin()
11796 
      if ftype == TType.STOP:
11797 
        break
11798 
      if fid == 0:
11799 
        if ftype == TType.STRUCT:
11800 
          self.success = Category()
11801 
          self.success.read(iprot)
11802 
        else:
11803 
          iprot.skip(ftype)
11804 
      else:
11805 
        iprot.skip(ftype)
11806 
      iprot.readFieldEnd()
11807 
    iprot.readStructEnd()
11808 
 
11809 
  def write(self, oprot):
11810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11812 
      return
11813 
    oprot.writeStructBegin('getCategory_result')
11814 
    if self.success is not None:
11815 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11816 
      self.success.write(oprot)
11817 
      oprot.writeFieldEnd()
11818 
    oprot.writeFieldStop()
11819 
    oprot.writeStructEnd()
11820 
 
11821 
  def validate(self):
11822 
    return
11823 
 
11824 
 
11825 
  def __repr__(self):
11826 
    L = ['%s=%r' % (key, value)
11827 
      for key, value in self.__dict__.iteritems()]
11828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11829 
 
11830 
  def __eq__(self, other):
11831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11832 
 
11833 
  def __ne__(self, other):
11834 
    return not (self == other)
11835 
 
11836 
class getAllCategories_args:
11837 
 
11838 
  thrift_spec = (
11839 
  )
11840 
 
11841 
  def read(self, iprot):
11842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11844 
      return
11845 
    iprot.readStructBegin()
11846 
    while True:
11847 
      (fname, ftype, fid) = iprot.readFieldBegin()
11848 
      if ftype == TType.STOP:
11849 
        break
11850 
      else:
11851 
        iprot.skip(ftype)
11852 
      iprot.readFieldEnd()
11853 
    iprot.readStructEnd()
11854 
 
11855 
  def write(self, oprot):
11856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11858 
      return
11859 
    oprot.writeStructBegin('getAllCategories_args')
11860 
    oprot.writeFieldStop()
11861 
    oprot.writeStructEnd()
11862 
 
11863 
  def validate(self):
11864 
    return
11865 
 
11866 
 
11867 
  def __repr__(self):
11868 
    L = ['%s=%r' % (key, value)
11869 
      for key, value in self.__dict__.iteritems()]
11870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11871 
 
11872 
  def __eq__(self, other):
11873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11874 
 
11875 
  def __ne__(self, other):
11876 
    return not (self == other)
11877 
 
11878 
class getAllCategories_result:
11879 
  """
11880 
  Attributes:
11881 
   - success
11882 
  """
11883 
 
11884 
  thrift_spec = (
11885 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
11886 
  )
11887 
 
11888 
  def __init__(self, success=None,):
11889 
    self.success = success
11890 
 
11891 
  def read(self, iprot):
11892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11894 
      return
11895 
    iprot.readStructBegin()
11896 
    while True:
11897 
      (fname, ftype, fid) = iprot.readFieldBegin()
11898 
      if ftype == TType.STOP:
11899 
        break
11900 
      if fid == 0:
11901 
        if ftype == TType.LIST:
11902 
          self.success = []
8590 kshitij.so 11903 
          (_etype154, _size151) = iprot.readListBegin()
11904 
          for _i155 in xrange(_size151):
11905 
            _elem156 = Category()
11906 
            _elem156.read(iprot)
11907 
            self.success.append(_elem156)
5944 mandeep.dh 11908 
          iprot.readListEnd()
11909 
        else:
11910 
          iprot.skip(ftype)
11911 
      else:
11912 
        iprot.skip(ftype)
11913 
      iprot.readFieldEnd()
11914 
    iprot.readStructEnd()
11915 
 
11916 
  def write(self, oprot):
11917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11919 
      return
11920 
    oprot.writeStructBegin('getAllCategories_result')
11921 
    if self.success is not None:
11922 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11923 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11924 
      for iter157 in self.success:
11925 
        iter157.write(oprot)
5944 mandeep.dh 11926 
      oprot.writeListEnd()
11927 
      oprot.writeFieldEnd()
11928 
    oprot.writeFieldStop()
11929 
    oprot.writeStructEnd()
11930 
 
11931 
  def validate(self):
11932 
    return
11933 
 
11934 
 
11935 
  def __repr__(self):
11936 
    L = ['%s=%r' % (key, value)
11937 
      for key, value in self.__dict__.iteritems()]
11938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11939 
 
11940 
  def __eq__(self, other):
11941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11942 
 
11943 
  def __ne__(self, other):
11944 
    return not (self == other)
11945 
 
11946 
class getAllSimilarItems_args:
11947 
  """
11948 
  Attributes:
11949 
   - itemId
11950 
  """
11951 
 
11952 
  thrift_spec = (
11953 
    None, # 0
11954 
    (1, TType.I64, 'itemId', None, None, ), # 1
11955 
  )
11956 
 
11957 
  def __init__(self, itemId=None,):
11958 
    self.itemId = itemId
11959 
 
11960 
  def read(self, iprot):
11961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11963 
      return
11964 
    iprot.readStructBegin()
11965 
    while True:
11966 
      (fname, ftype, fid) = iprot.readFieldBegin()
11967 
      if ftype == TType.STOP:
11968 
        break
11969 
      if fid == 1:
11970 
        if ftype == TType.I64:
11971 
          self.itemId = iprot.readI64();
11972 
        else:
11973 
          iprot.skip(ftype)
11974 
      else:
11975 
        iprot.skip(ftype)
11976 
      iprot.readFieldEnd()
11977 
    iprot.readStructEnd()
11978 
 
11979 
  def write(self, oprot):
11980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11982 
      return
11983 
    oprot.writeStructBegin('getAllSimilarItems_args')
11984 
    if self.itemId is not None:
11985 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11986 
      oprot.writeI64(self.itemId)
11987 
      oprot.writeFieldEnd()
11988 
    oprot.writeFieldStop()
11989 
    oprot.writeStructEnd()
11990 
 
11991 
  def validate(self):
11992 
    return
11993 
 
11994 
 
11995 
  def __repr__(self):
11996 
    L = ['%s=%r' % (key, value)
11997 
      for key, value in self.__dict__.iteritems()]
11998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11999 
 
12000 
  def __eq__(self, other):
12001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12002 
 
12003 
  def __ne__(self, other):
12004 
    return not (self == other)
12005 
 
12006 
class getAllSimilarItems_result:
12007 
  """
12008 
  Attributes:
12009 
   - success
12010 
  """
12011 
 
12012 
  thrift_spec = (
12013 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12014 
  )
12015 
 
12016 
  def __init__(self, success=None,):
12017 
    self.success = success
12018 
 
12019 
  def read(self, iprot):
12020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12022 
      return
12023 
    iprot.readStructBegin()
12024 
    while True:
12025 
      (fname, ftype, fid) = iprot.readFieldBegin()
12026 
      if ftype == TType.STOP:
12027 
        break
12028 
      if fid == 0:
12029 
        if ftype == TType.LIST:
12030 
          self.success = []
8590 kshitij.so 12031 
          (_etype161, _size158) = iprot.readListBegin()
12032 
          for _i162 in xrange(_size158):
12033 
            _elem163 = Item()
12034 
            _elem163.read(iprot)
12035 
            self.success.append(_elem163)
5944 mandeep.dh 12036 
          iprot.readListEnd()
12037 
        else:
12038 
          iprot.skip(ftype)
12039 
      else:
12040 
        iprot.skip(ftype)
12041 
      iprot.readFieldEnd()
12042 
    iprot.readStructEnd()
12043 
 
12044 
  def write(self, oprot):
12045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12047 
      return
12048 
    oprot.writeStructBegin('getAllSimilarItems_result')
12049 
    if self.success is not None:
12050 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12051 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12052 
      for iter164 in self.success:
12053 
        iter164.write(oprot)
5944 mandeep.dh 12054 
      oprot.writeListEnd()
12055 
      oprot.writeFieldEnd()
12056 
    oprot.writeFieldStop()
12057 
    oprot.writeStructEnd()
12058 
 
12059 
  def validate(self):
12060 
    return
12061 
 
12062 
 
12063 
  def __repr__(self):
12064 
    L = ['%s=%r' % (key, value)
12065 
      for key, value in self.__dict__.iteritems()]
12066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12067 
 
12068 
  def __eq__(self, other):
12069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12070 
 
12071 
  def __ne__(self, other):
12072 
    return not (self == other)
12073 
 
12074 
class addSimilarItem_args:
12075 
  """
12076 
  Attributes:
12077 
   - itemId
12078 
   - catalogItemId
12079 
  """
12080 
 
12081 
  thrift_spec = (
12082 
    None, # 0
12083 
    (1, TType.I64, 'itemId', None, None, ), # 1
12084 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
12085 
  )
12086 
 
12087 
  def __init__(self, itemId=None, catalogItemId=None,):
12088 
    self.itemId = itemId
12089 
    self.catalogItemId = catalogItemId
12090 
 
12091 
  def read(self, iprot):
12092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12094 
      return
12095 
    iprot.readStructBegin()
12096 
    while True:
12097 
      (fname, ftype, fid) = iprot.readFieldBegin()
12098 
      if ftype == TType.STOP:
12099 
        break
12100 
      if fid == 1:
12101 
        if ftype == TType.I64:
12102 
          self.itemId = iprot.readI64();
12103 
        else:
12104 
          iprot.skip(ftype)
12105 
      elif fid == 2:
12106 
        if ftype == TType.I64:
12107 
          self.catalogItemId = iprot.readI64();
12108 
        else:
12109 
          iprot.skip(ftype)
12110 
      else:
12111 
        iprot.skip(ftype)
12112 
      iprot.readFieldEnd()
12113 
    iprot.readStructEnd()
12114 
 
12115 
  def write(self, oprot):
12116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12118 
      return
12119 
    oprot.writeStructBegin('addSimilarItem_args')
12120 
    if self.itemId is not None:
12121 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12122 
      oprot.writeI64(self.itemId)
12123 
      oprot.writeFieldEnd()
12124 
    if self.catalogItemId is not None:
12125 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
12126 
      oprot.writeI64(self.catalogItemId)
12127 
      oprot.writeFieldEnd()
12128 
    oprot.writeFieldStop()
12129 
    oprot.writeStructEnd()
12130 
 
12131 
  def validate(self):
12132 
    return
12133 
 
12134 
 
12135 
  def __repr__(self):
12136 
    L = ['%s=%r' % (key, value)
12137 
      for key, value in self.__dict__.iteritems()]
12138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12139 
 
12140 
  def __eq__(self, other):
12141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12142 
 
12143 
  def __ne__(self, other):
12144 
    return not (self == other)
12145 
 
12146 
class addSimilarItem_result:
12147 
  """
12148 
  Attributes:
12149 
   - success
12150 
   - cex
12151 
  """
12152 
 
12153 
  thrift_spec = (
12154 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
12155 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12156 
  )
12157 
 
12158 
  def __init__(self, success=None, cex=None,):
12159 
    self.success = success
12160 
    self.cex = cex
12161 
 
12162 
  def read(self, iprot):
12163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12165 
      return
12166 
    iprot.readStructBegin()
12167 
    while True:
12168 
      (fname, ftype, fid) = iprot.readFieldBegin()
12169 
      if ftype == TType.STOP:
12170 
        break
12171 
      if fid == 0:
12172 
        if ftype == TType.STRUCT:
12173 
          self.success = Item()
12174 
          self.success.read(iprot)
12175 
        else:
12176 
          iprot.skip(ftype)
12177 
      elif fid == 1:
12178 
        if ftype == TType.STRUCT:
12179 
          self.cex = CatalogServiceException()
12180 
          self.cex.read(iprot)
12181 
        else:
12182 
          iprot.skip(ftype)
12183 
      else:
12184 
        iprot.skip(ftype)
12185 
      iprot.readFieldEnd()
12186 
    iprot.readStructEnd()
12187 
 
12188 
  def write(self, oprot):
12189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12191 
      return
12192 
    oprot.writeStructBegin('addSimilarItem_result')
12193 
    if self.success is not None:
12194 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12195 
      self.success.write(oprot)
12196 
      oprot.writeFieldEnd()
12197 
    if self.cex is not None:
12198 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12199 
      self.cex.write(oprot)
12200 
      oprot.writeFieldEnd()
12201 
    oprot.writeFieldStop()
12202 
    oprot.writeStructEnd()
12203 
 
12204 
  def validate(self):
12205 
    return
12206 
 
12207 
 
12208 
  def __repr__(self):
12209 
    L = ['%s=%r' % (key, value)
12210 
      for key, value in self.__dict__.iteritems()]
12211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12212 
 
12213 
  def __eq__(self, other):
12214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12215 
 
12216 
  def __ne__(self, other):
12217 
    return not (self == other)
12218 
 
6512 kshitij.so 12219 
class addTag_args:
12220 
  """
12221 
  Attributes:
12222 
   - displayName
12223 
   - itemId
12224 
  """
12225 
 
12226 
  thrift_spec = (
12227 
    None, # 0
12228 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12229 
    (2, TType.I64, 'itemId', None, None, ), # 2
12230 
  )
12231 
 
12232 
  def __init__(self, displayName=None, itemId=None,):
12233 
    self.displayName = displayName
12234 
    self.itemId = itemId
12235 
 
12236 
  def read(self, iprot):
12237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12239 
      return
12240 
    iprot.readStructBegin()
12241 
    while True:
12242 
      (fname, ftype, fid) = iprot.readFieldBegin()
12243 
      if ftype == TType.STOP:
12244 
        break
12245 
      if fid == 1:
12246 
        if ftype == TType.STRING:
12247 
          self.displayName = iprot.readString();
12248 
        else:
12249 
          iprot.skip(ftype)
12250 
      elif fid == 2:
12251 
        if ftype == TType.I64:
12252 
          self.itemId = iprot.readI64();
12253 
        else:
12254 
          iprot.skip(ftype)
12255 
      else:
12256 
        iprot.skip(ftype)
12257 
      iprot.readFieldEnd()
12258 
    iprot.readStructEnd()
12259 
 
12260 
  def write(self, oprot):
12261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12263 
      return
12264 
    oprot.writeStructBegin('addTag_args')
12265 
    if self.displayName is not None:
12266 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12267 
      oprot.writeString(self.displayName)
12268 
      oprot.writeFieldEnd()
12269 
    if self.itemId is not None:
12270 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12271 
      oprot.writeI64(self.itemId)
12272 
      oprot.writeFieldEnd()
12273 
    oprot.writeFieldStop()
12274 
    oprot.writeStructEnd()
12275 
 
12276 
  def validate(self):
12277 
    return
12278 
 
12279 
 
12280 
  def __repr__(self):
12281 
    L = ['%s=%r' % (key, value)
12282 
      for key, value in self.__dict__.iteritems()]
12283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12284 
 
12285 
  def __eq__(self, other):
12286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12287 
 
12288 
  def __ne__(self, other):
12289 
    return not (self == other)
12290 
 
12291 
class addTag_result:
12292 
  """
12293 
  Attributes:
12294 
   - success
12295 
  """
12296 
 
12297 
  thrift_spec = (
12298 
    (0, TType.BOOL, 'success', None, None, ), # 0
12299 
  )
12300 
 
12301 
  def __init__(self, success=None,):
12302 
    self.success = success
12303 
 
12304 
  def read(self, iprot):
12305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12307 
      return
12308 
    iprot.readStructBegin()
12309 
    while True:
12310 
      (fname, ftype, fid) = iprot.readFieldBegin()
12311 
      if ftype == TType.STOP:
12312 
        break
12313 
      if fid == 0:
12314 
        if ftype == TType.BOOL:
12315 
          self.success = iprot.readBool();
12316 
        else:
12317 
          iprot.skip(ftype)
12318 
      else:
12319 
        iprot.skip(ftype)
12320 
      iprot.readFieldEnd()
12321 
    iprot.readStructEnd()
12322 
 
12323 
  def write(self, oprot):
12324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12326 
      return
12327 
    oprot.writeStructBegin('addTag_result')
12328 
    if self.success is not None:
12329 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12330 
      oprot.writeBool(self.success)
12331 
      oprot.writeFieldEnd()
12332 
    oprot.writeFieldStop()
12333 
    oprot.writeStructEnd()
12334 
 
12335 
  def validate(self):
12336 
    return
12337 
 
12338 
 
12339 
  def __repr__(self):
12340 
    L = ['%s=%r' % (key, value)
12341 
      for key, value in self.__dict__.iteritems()]
12342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12343 
 
12344 
  def __eq__(self, other):
12345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12346 
 
12347 
  def __ne__(self, other):
12348 
    return not (self == other)
12349 
 
12350 
class deleteEntityTag_args:
12351 
  """
12352 
  Attributes:
12353 
   - displayName
12354 
   - itemId
12355 
  """
12356 
 
12357 
  thrift_spec = (
12358 
    None, # 0
12359 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12360 
    (2, TType.I64, 'itemId', None, None, ), # 2
12361 
  )
12362 
 
12363 
  def __init__(self, displayName=None, itemId=None,):
12364 
    self.displayName = displayName
12365 
    self.itemId = itemId
12366 
 
12367 
  def read(self, iprot):
12368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12370 
      return
12371 
    iprot.readStructBegin()
12372 
    while True:
12373 
      (fname, ftype, fid) = iprot.readFieldBegin()
12374 
      if ftype == TType.STOP:
12375 
        break
12376 
      if fid == 1:
12377 
        if ftype == TType.STRING:
12378 
          self.displayName = iprot.readString();
12379 
        else:
12380 
          iprot.skip(ftype)
12381 
      elif fid == 2:
12382 
        if ftype == TType.I64:
12383 
          self.itemId = iprot.readI64();
12384 
        else:
12385 
          iprot.skip(ftype)
12386 
      else:
12387 
        iprot.skip(ftype)
12388 
      iprot.readFieldEnd()
12389 
    iprot.readStructEnd()
12390 
 
12391 
  def write(self, oprot):
12392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12394 
      return
12395 
    oprot.writeStructBegin('deleteEntityTag_args')
12396 
    if self.displayName is not None:
12397 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12398 
      oprot.writeString(self.displayName)
12399 
      oprot.writeFieldEnd()
12400 
    if self.itemId is not None:
12401 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12402 
      oprot.writeI64(self.itemId)
12403 
      oprot.writeFieldEnd()
12404 
    oprot.writeFieldStop()
12405 
    oprot.writeStructEnd()
12406 
 
12407 
  def validate(self):
12408 
    return
12409 
 
12410 
 
12411 
  def __repr__(self):
12412 
    L = ['%s=%r' % (key, value)
12413 
      for key, value in self.__dict__.iteritems()]
12414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12415 
 
12416 
  def __eq__(self, other):
12417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12418 
 
12419 
  def __ne__(self, other):
12420 
    return not (self == other)
12421 
 
12422 
class deleteEntityTag_result:
12423 
  """
12424 
  Attributes:
12425 
   - success
12426 
  """
12427 
 
12428 
  thrift_spec = (
12429 
    (0, TType.BOOL, 'success', None, None, ), # 0
12430 
  )
12431 
 
12432 
  def __init__(self, success=None,):
12433 
    self.success = success
12434 
 
12435 
  def read(self, iprot):
12436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12438 
      return
12439 
    iprot.readStructBegin()
12440 
    while True:
12441 
      (fname, ftype, fid) = iprot.readFieldBegin()
12442 
      if ftype == TType.STOP:
12443 
        break
12444 
      if fid == 0:
12445 
        if ftype == TType.BOOL:
12446 
          self.success = iprot.readBool();
12447 
        else:
12448 
          iprot.skip(ftype)
12449 
      else:
12450 
        iprot.skip(ftype)
12451 
      iprot.readFieldEnd()
12452 
    iprot.readStructEnd()
12453 
 
12454 
  def write(self, oprot):
12455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12457 
      return
12458 
    oprot.writeStructBegin('deleteEntityTag_result')
12459 
    if self.success is not None:
12460 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12461 
      oprot.writeBool(self.success)
12462 
      oprot.writeFieldEnd()
12463 
    oprot.writeFieldStop()
12464 
    oprot.writeStructEnd()
12465 
 
12466 
  def validate(self):
12467 
    return
12468 
 
12469 
 
12470 
  def __repr__(self):
12471 
    L = ['%s=%r' % (key, value)
12472 
      for key, value in self.__dict__.iteritems()]
12473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12474 
 
12475 
  def __eq__(self, other):
12476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12477 
 
12478 
  def __ne__(self, other):
12479 
    return not (self == other)
12480 
 
12481 
class deleteTag_args:
12482 
  """
12483 
  Attributes:
12484 
   - displayName
12485 
  """
12486 
 
12487 
  thrift_spec = (
12488 
    None, # 0
12489 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12490 
  )
12491 
 
12492 
  def __init__(self, displayName=None,):
12493 
    self.displayName = displayName
12494 
 
12495 
  def read(self, iprot):
12496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12498 
      return
12499 
    iprot.readStructBegin()
12500 
    while True:
12501 
      (fname, ftype, fid) = iprot.readFieldBegin()
12502 
      if ftype == TType.STOP:
12503 
        break
12504 
      if fid == 1:
12505 
        if ftype == TType.STRING:
12506 
          self.displayName = iprot.readString();
12507 
        else:
12508 
          iprot.skip(ftype)
12509 
      else:
12510 
        iprot.skip(ftype)
12511 
      iprot.readFieldEnd()
12512 
    iprot.readStructEnd()
12513 
 
12514 
  def write(self, oprot):
12515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12517 
      return
12518 
    oprot.writeStructBegin('deleteTag_args')
12519 
    if self.displayName is not None:
12520 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12521 
      oprot.writeString(self.displayName)
12522 
      oprot.writeFieldEnd()
12523 
    oprot.writeFieldStop()
12524 
    oprot.writeStructEnd()
12525 
 
12526 
  def validate(self):
12527 
    return
12528 
 
12529 
 
12530 
  def __repr__(self):
12531 
    L = ['%s=%r' % (key, value)
12532 
      for key, value in self.__dict__.iteritems()]
12533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12534 
 
12535 
  def __eq__(self, other):
12536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12537 
 
12538 
  def __ne__(self, other):
12539 
    return not (self == other)
12540 
 
12541 
class deleteTag_result:
12542 
  """
12543 
  Attributes:
12544 
   - success
12545 
  """
12546 
 
12547 
  thrift_spec = (
12548 
    (0, TType.BOOL, 'success', None, None, ), # 0
12549 
  )
12550 
 
12551 
  def __init__(self, success=None,):
12552 
    self.success = success
12553 
 
12554 
  def read(self, iprot):
12555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12557 
      return
12558 
    iprot.readStructBegin()
12559 
    while True:
12560 
      (fname, ftype, fid) = iprot.readFieldBegin()
12561 
      if ftype == TType.STOP:
12562 
        break
12563 
      if fid == 0:
12564 
        if ftype == TType.BOOL:
12565 
          self.success = iprot.readBool();
12566 
        else:
12567 
          iprot.skip(ftype)
12568 
      else:
12569 
        iprot.skip(ftype)
12570 
      iprot.readFieldEnd()
12571 
    iprot.readStructEnd()
12572 
 
12573 
  def write(self, oprot):
12574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12576 
      return
12577 
    oprot.writeStructBegin('deleteTag_result')
12578 
    if self.success is not None:
12579 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12580 
      oprot.writeBool(self.success)
12581 
      oprot.writeFieldEnd()
12582 
    oprot.writeFieldStop()
12583 
    oprot.writeStructEnd()
12584 
 
12585 
  def validate(self):
12586 
    return
12587 
 
12588 
 
12589 
  def __repr__(self):
12590 
    L = ['%s=%r' % (key, value)
12591 
      for key, value in self.__dict__.iteritems()]
12592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12593 
 
12594 
  def __eq__(self, other):
12595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12596 
 
12597 
  def __ne__(self, other):
12598 
    return not (self == other)
12599 
 
12600 
class getAllTags_args:
12601 
 
12602 
  thrift_spec = (
12603 
  )
12604 
 
12605 
  def read(self, iprot):
12606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12608 
      return
12609 
    iprot.readStructBegin()
12610 
    while True:
12611 
      (fname, ftype, fid) = iprot.readFieldBegin()
12612 
      if ftype == TType.STOP:
12613 
        break
12614 
      else:
12615 
        iprot.skip(ftype)
12616 
      iprot.readFieldEnd()
12617 
    iprot.readStructEnd()
12618 
 
12619 
  def write(self, oprot):
12620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12622 
      return
12623 
    oprot.writeStructBegin('getAllTags_args')
12624 
    oprot.writeFieldStop()
12625 
    oprot.writeStructEnd()
12626 
 
12627 
  def validate(self):
12628 
    return
12629 
 
12630 
 
12631 
  def __repr__(self):
12632 
    L = ['%s=%r' % (key, value)
12633 
      for key, value in self.__dict__.iteritems()]
12634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12635 
 
12636 
  def __eq__(self, other):
12637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12638 
 
12639 
  def __ne__(self, other):
12640 
    return not (self == other)
12641 
 
12642 
class getAllTags_result:
12643 
  """
12644 
  Attributes:
12645 
   - success
12646 
  """
12647 
 
12648 
  thrift_spec = (
12649 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12650 
  )
12651 
 
12652 
  def __init__(self, success=None,):
12653 
    self.success = success
12654 
 
12655 
  def read(self, iprot):
12656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12658 
      return
12659 
    iprot.readStructBegin()
12660 
    while True:
12661 
      (fname, ftype, fid) = iprot.readFieldBegin()
12662 
      if ftype == TType.STOP:
12663 
        break
12664 
      if fid == 0:
12665 
        if ftype == TType.LIST:
12666 
          self.success = []
8590 kshitij.so 12667 
          (_etype168, _size165) = iprot.readListBegin()
12668 
          for _i169 in xrange(_size165):
12669 
            _elem170 = iprot.readString();
12670 
            self.success.append(_elem170)
6512 kshitij.so 12671 
          iprot.readListEnd()
12672 
        else:
12673 
          iprot.skip(ftype)
12674 
      else:
12675 
        iprot.skip(ftype)
12676 
      iprot.readFieldEnd()
12677 
    iprot.readStructEnd()
12678 
 
12679 
  def write(self, oprot):
12680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12682 
      return
12683 
    oprot.writeStructBegin('getAllTags_result')
12684 
    if self.success is not None:
12685 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12686 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 12687 
      for iter171 in self.success:
12688 
        oprot.writeString(iter171)
6512 kshitij.so 12689 
      oprot.writeListEnd()
12690 
      oprot.writeFieldEnd()
12691 
    oprot.writeFieldStop()
12692 
    oprot.writeStructEnd()
12693 
 
12694 
  def validate(self):
12695 
    return
12696 
 
12697 
 
12698 
  def __repr__(self):
12699 
    L = ['%s=%r' % (key, value)
12700 
      for key, value in self.__dict__.iteritems()]
12701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12702 
 
12703 
  def __eq__(self, other):
12704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12705 
 
12706 
  def __ne__(self, other):
12707 
    return not (self == other)
12708 
 
12709 
class getAllEntitiesByTagName_args:
12710 
  """
12711 
  Attributes:
12712 
   - displayName
12713 
  """
12714 
 
12715 
  thrift_spec = (
12716 
    None, # 0
12717 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12718 
  )
12719 
 
12720 
  def __init__(self, displayName=None,):
12721 
    self.displayName = displayName
12722 
 
12723 
  def read(self, iprot):
12724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12726 
      return
12727 
    iprot.readStructBegin()
12728 
    while True:
12729 
      (fname, ftype, fid) = iprot.readFieldBegin()
12730 
      if ftype == TType.STOP:
12731 
        break
12732 
      if fid == 1:
12733 
        if ftype == TType.STRING:
12734 
          self.displayName = iprot.readString();
12735 
        else:
12736 
          iprot.skip(ftype)
12737 
      else:
12738 
        iprot.skip(ftype)
12739 
      iprot.readFieldEnd()
12740 
    iprot.readStructEnd()
12741 
 
12742 
  def write(self, oprot):
12743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12745 
      return
12746 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
12747 
    if self.displayName is not None:
12748 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12749 
      oprot.writeString(self.displayName)
12750 
      oprot.writeFieldEnd()
12751 
    oprot.writeFieldStop()
12752 
    oprot.writeStructEnd()
12753 
 
12754 
  def validate(self):
12755 
    return
12756 
 
12757 
 
12758 
  def __repr__(self):
12759 
    L = ['%s=%r' % (key, value)
12760 
      for key, value in self.__dict__.iteritems()]
12761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12762 
 
12763 
  def __eq__(self, other):
12764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12765 
 
12766 
  def __ne__(self, other):
12767 
    return not (self == other)
12768 
 
12769 
class getAllEntitiesByTagName_result:
12770 
  """
12771 
  Attributes:
12772 
   - success
12773 
  """
12774 
 
12775 
  thrift_spec = (
12776 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12777 
  )
12778 
 
12779 
  def __init__(self, success=None,):
12780 
    self.success = success
12781 
 
12782 
  def read(self, iprot):
12783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12785 
      return
12786 
    iprot.readStructBegin()
12787 
    while True:
12788 
      (fname, ftype, fid) = iprot.readFieldBegin()
12789 
      if ftype == TType.STOP:
12790 
        break
12791 
      if fid == 0:
12792 
        if ftype == TType.LIST:
12793 
          self.success = []
8590 kshitij.so 12794 
          (_etype175, _size172) = iprot.readListBegin()
12795 
          for _i176 in xrange(_size172):
12796 
            _elem177 = iprot.readI64();
12797 
            self.success.append(_elem177)
6512 kshitij.so 12798 
          iprot.readListEnd()
12799 
        else:
12800 
          iprot.skip(ftype)
12801 
      else:
12802 
        iprot.skip(ftype)
12803 
      iprot.readFieldEnd()
12804 
    iprot.readStructEnd()
12805 
 
12806 
  def write(self, oprot):
12807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12809 
      return
12810 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
12811 
    if self.success is not None:
12812 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12813 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12814 
      for iter178 in self.success:
12815 
        oprot.writeI64(iter178)
6512 kshitij.so 12816 
      oprot.writeListEnd()
12817 
      oprot.writeFieldEnd()
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 
 
6845 amit.gupta 12836 
class getAllEntityTags_args:
12837 
 
12838 
  thrift_spec = (
12839 
  )
12840 
 
12841 
  def read(self, iprot):
12842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12844 
      return
12845 
    iprot.readStructBegin()
12846 
    while True:
12847 
      (fname, ftype, fid) = iprot.readFieldBegin()
12848 
      if ftype == TType.STOP:
12849 
        break
12850 
      else:
12851 
        iprot.skip(ftype)
12852 
      iprot.readFieldEnd()
12853 
    iprot.readStructEnd()
12854 
 
12855 
  def write(self, oprot):
12856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12858 
      return
12859 
    oprot.writeStructBegin('getAllEntityTags_args')
12860 
    oprot.writeFieldStop()
12861 
    oprot.writeStructEnd()
12862 
 
12863 
  def validate(self):
12864 
    return
12865 
 
12866 
 
12867 
  def __repr__(self):
12868 
    L = ['%s=%r' % (key, value)
12869 
      for key, value in self.__dict__.iteritems()]
12870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12871 
 
12872 
  def __eq__(self, other):
12873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12874 
 
12875 
  def __ne__(self, other):
12876 
    return not (self == other)
12877 
 
12878 
class getAllEntityTags_result:
12879 
  """
12880 
  Attributes:
12881 
   - success
12882 
  """
12883 
 
12884 
  thrift_spec = (
12885 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
12886 
  )
12887 
 
12888 
  def __init__(self, success=None,):
12889 
    self.success = success
12890 
 
12891 
  def read(self, iprot):
12892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12894 
      return
12895 
    iprot.readStructBegin()
12896 
    while True:
12897 
      (fname, ftype, fid) = iprot.readFieldBegin()
12898 
      if ftype == TType.STOP:
12899 
        break
12900 
      if fid == 0:
12901 
        if ftype == TType.MAP:
12902 
          self.success = {}
8590 kshitij.so 12903 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
12904 
          for _i183 in xrange(_size179):
12905 
            _key184 = iprot.readI64();
12906 
            _val185 = []
12907 
            (_etype189, _size186) = iprot.readListBegin()
12908 
            for _i190 in xrange(_size186):
12909 
              _elem191 = iprot.readString();
12910 
              _val185.append(_elem191)
6845 amit.gupta 12911 
            iprot.readListEnd()
8590 kshitij.so 12912 
            self.success[_key184] = _val185
6845 amit.gupta 12913 
          iprot.readMapEnd()
12914 
        else:
12915 
          iprot.skip(ftype)
12916 
      else:
12917 
        iprot.skip(ftype)
12918 
      iprot.readFieldEnd()
12919 
    iprot.readStructEnd()
12920 
 
12921 
  def write(self, oprot):
12922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12924 
      return
12925 
    oprot.writeStructBegin('getAllEntityTags_result')
12926 
    if self.success is not None:
12927 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12928 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 12929 
      for kiter192,viter193 in self.success.items():
12930 
        oprot.writeI64(kiter192)
12931 
        oprot.writeListBegin(TType.STRING, len(viter193))
12932 
        for iter194 in viter193:
12933 
          oprot.writeString(iter194)
6845 amit.gupta 12934 
        oprot.writeListEnd()
12935 
      oprot.writeMapEnd()
12936 
      oprot.writeFieldEnd()
12937 
    oprot.writeFieldStop()
12938 
    oprot.writeStructEnd()
12939 
 
12940 
  def validate(self):
12941 
    return
12942 
 
12943 
 
12944 
  def __repr__(self):
12945 
    L = ['%s=%r' % (key, value)
12946 
      for key, value in self.__dict__.iteritems()]
12947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12948 
 
12949 
  def __eq__(self, other):
12950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12951 
 
12952 
  def __ne__(self, other):
12953 
    return not (self == other)
12954 
 
6850 kshitij.so 12955 
class addBanner_args:
12956 
  """
12957 
  Attributes:
8590 kshitij.so 12958 
   - bannerCongregate
6850 kshitij.so 12959 
  """
12960 
 
12961 
  thrift_spec = (
12962 
    None, # 0
8590 kshitij.so 12963 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 12964 
  )
12965 
 
8590 kshitij.so 12966 
  def __init__(self, bannerCongregate=None,):
12967 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 12968 
 
12969 
  def read(self, iprot):
12970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12972 
      return
12973 
    iprot.readStructBegin()
12974 
    while True:
12975 
      (fname, ftype, fid) = iprot.readFieldBegin()
12976 
      if ftype == TType.STOP:
12977 
        break
12978 
      if fid == 1:
8579 kshitij.so 12979 
        if ftype == TType.STRUCT:
8590 kshitij.so 12980 
          self.bannerCongregate = BannerCongregate()
12981 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 12982 
        else:
12983 
          iprot.skip(ftype)
8579 kshitij.so 12984 
      else:
12985 
        iprot.skip(ftype)
12986 
      iprot.readFieldEnd()
12987 
    iprot.readStructEnd()
12988 
 
12989 
  def write(self, oprot):
12990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12992 
      return
12993 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 12994 
    if self.bannerCongregate is not None:
12995 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
12996 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 12997 
      oprot.writeFieldEnd()
12998 
    oprot.writeFieldStop()
12999 
    oprot.writeStructEnd()
13000 
 
13001 
  def validate(self):
13002 
    return
13003 
 
13004 
 
13005 
  def __repr__(self):
13006 
    L = ['%s=%r' % (key, value)
13007 
      for key, value in self.__dict__.iteritems()]
13008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13009 
 
13010 
  def __eq__(self, other):
13011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13012 
 
13013 
  def __ne__(self, other):
13014 
    return not (self == other)
13015 
 
13016 
class addBanner_result:
13017 
 
13018 
  thrift_spec = (
13019 
  )
13020 
 
13021 
  def read(self, iprot):
13022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13024 
      return
13025 
    iprot.readStructBegin()
13026 
    while True:
13027 
      (fname, ftype, fid) = iprot.readFieldBegin()
13028 
      if ftype == TType.STOP:
13029 
        break
13030 
      else:
13031 
        iprot.skip(ftype)
13032 
      iprot.readFieldEnd()
13033 
    iprot.readStructEnd()
13034 
 
13035 
  def write(self, oprot):
13036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13038 
      return
13039 
    oprot.writeStructBegin('addBanner_result')
13040 
    oprot.writeFieldStop()
13041 
    oprot.writeStructEnd()
13042 
 
13043 
  def validate(self):
13044 
    return
13045 
 
13046 
 
13047 
  def __repr__(self):
13048 
    L = ['%s=%r' % (key, value)
13049 
      for key, value in self.__dict__.iteritems()]
13050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13051 
 
13052 
  def __eq__(self, other):
13053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13054 
 
13055 
  def __ne__(self, other):
13056 
    return not (self == other)
13057 
 
13058 
class updateBanner_args:
13059 
  """
13060 
  Attributes:
13061 
   - banner
13062 
  """
13063 
 
13064 
  thrift_spec = (
13065 
    None, # 0
13066 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
13067 
  )
13068 
 
13069 
  def __init__(self, banner=None,):
13070 
    self.banner = banner
13071 
 
13072 
  def read(self, iprot):
13073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13075 
      return
13076 
    iprot.readStructBegin()
13077 
    while True:
13078 
      (fname, ftype, fid) = iprot.readFieldBegin()
13079 
      if ftype == TType.STOP:
13080 
        break
13081 
      if fid == 1:
13082 
        if ftype == TType.STRUCT:
13083 
          self.banner = Banner()
13084 
          self.banner.read(iprot)
6850 kshitij.so 13085 
        else:
13086 
          iprot.skip(ftype)
13087 
      else:
13088 
        iprot.skip(ftype)
13089 
      iprot.readFieldEnd()
13090 
    iprot.readStructEnd()
13091 
 
13092 
  def write(self, oprot):
13093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13095 
      return
8579 kshitij.so 13096 
    oprot.writeStructBegin('updateBanner_args')
13097 
    if self.banner is not None:
13098 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
13099 
      self.banner.write(oprot)
6850 kshitij.so 13100 
      oprot.writeFieldEnd()
13101 
    oprot.writeFieldStop()
13102 
    oprot.writeStructEnd()
13103 
 
13104 
  def validate(self):
13105 
    return
13106 
 
13107 
 
13108 
  def __repr__(self):
13109 
    L = ['%s=%r' % (key, value)
13110 
      for key, value in self.__dict__.iteritems()]
13111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13112 
 
13113 
  def __eq__(self, other):
13114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13115 
 
13116 
  def __ne__(self, other):
13117 
    return not (self == other)
13118 
 
8579 kshitij.so 13119 
class updateBanner_result:
6850 kshitij.so 13120 
  """
13121 
  Attributes:
13122 
   - success
13123 
  """
13124 
 
13125 
  thrift_spec = (
13126 
    (0, TType.BOOL, 'success', None, None, ), # 0
13127 
  )
13128 
 
13129 
  def __init__(self, success=None,):
13130 
    self.success = success
13131 
 
13132 
  def read(self, iprot):
13133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13135 
      return
13136 
    iprot.readStructBegin()
13137 
    while True:
13138 
      (fname, ftype, fid) = iprot.readFieldBegin()
13139 
      if ftype == TType.STOP:
13140 
        break
13141 
      if fid == 0:
13142 
        if ftype == TType.BOOL:
13143 
          self.success = iprot.readBool();
13144 
        else:
13145 
          iprot.skip(ftype)
13146 
      else:
13147 
        iprot.skip(ftype)
13148 
      iprot.readFieldEnd()
13149 
    iprot.readStructEnd()
13150 
 
13151 
  def write(self, oprot):
13152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13154 
      return
8579 kshitij.so 13155 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 13156 
    if self.success is not None:
13157 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13158 
      oprot.writeBool(self.success)
13159 
      oprot.writeFieldEnd()
13160 
    oprot.writeFieldStop()
13161 
    oprot.writeStructEnd()
13162 
 
13163 
  def validate(self):
13164 
    return
13165 
 
13166 
 
13167 
  def __repr__(self):
13168 
    L = ['%s=%r' % (key, value)
13169 
      for key, value in self.__dict__.iteritems()]
13170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13171 
 
13172 
  def __eq__(self, other):
13173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13174 
 
13175 
  def __ne__(self, other):
13176 
    return not (self == other)
13177 
 
13178 
class getAllBanners_args:
13179 
 
13180 
  thrift_spec = (
13181 
  )
13182 
 
13183 
  def read(self, iprot):
13184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13186 
      return
13187 
    iprot.readStructBegin()
13188 
    while True:
13189 
      (fname, ftype, fid) = iprot.readFieldBegin()
13190 
      if ftype == TType.STOP:
13191 
        break
13192 
      else:
13193 
        iprot.skip(ftype)
13194 
      iprot.readFieldEnd()
13195 
    iprot.readStructEnd()
13196 
 
13197 
  def write(self, oprot):
13198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13200 
      return
13201 
    oprot.writeStructBegin('getAllBanners_args')
13202 
    oprot.writeFieldStop()
13203 
    oprot.writeStructEnd()
13204 
 
13205 
  def validate(self):
13206 
    return
13207 
 
13208 
 
13209 
  def __repr__(self):
13210 
    L = ['%s=%r' % (key, value)
13211 
      for key, value in self.__dict__.iteritems()]
13212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13213 
 
13214 
  def __eq__(self, other):
13215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13216 
 
13217 
  def __ne__(self, other):
13218 
    return not (self == other)
13219 
 
13220 
class getAllBanners_result:
13221 
  """
13222 
  Attributes:
13223 
   - success
13224 
  """
13225 
 
13226 
  thrift_spec = (
8579 kshitij.so 13227 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 13228 
  )
13229 
 
13230 
  def __init__(self, success=None,):
13231 
    self.success = success
13232 
 
13233 
  def read(self, iprot):
13234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13236 
      return
13237 
    iprot.readStructBegin()
13238 
    while True:
13239 
      (fname, ftype, fid) = iprot.readFieldBegin()
13240 
      if ftype == TType.STOP:
13241 
        break
13242 
      if fid == 0:
13243 
        if ftype == TType.LIST:
13244 
          self.success = []
8590 kshitij.so 13245 
          (_etype198, _size195) = iprot.readListBegin()
13246 
          for _i199 in xrange(_size195):
13247 
            _elem200 = Banner()
13248 
            _elem200.read(iprot)
13249 
            self.success.append(_elem200)
6850 kshitij.so 13250 
          iprot.readListEnd()
13251 
        else:
13252 
          iprot.skip(ftype)
13253 
      else:
13254 
        iprot.skip(ftype)
13255 
      iprot.readFieldEnd()
13256 
    iprot.readStructEnd()
13257 
 
13258 
  def write(self, oprot):
13259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13261 
      return
13262 
    oprot.writeStructBegin('getAllBanners_result')
13263 
    if self.success is not None:
13264 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 13265 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13266 
      for iter201 in self.success:
13267 
        iter201.write(oprot)
6850 kshitij.so 13268 
      oprot.writeListEnd()
13269 
      oprot.writeFieldEnd()
13270 
    oprot.writeFieldStop()
13271 
    oprot.writeStructEnd()
13272 
 
13273 
  def validate(self):
13274 
    return
13275 
 
13276 
 
13277 
  def __repr__(self):
13278 
    L = ['%s=%r' % (key, value)
13279 
      for key, value in self.__dict__.iteritems()]
13280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13281 
 
13282 
  def __eq__(self, other):
13283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13284 
 
13285 
  def __ne__(self, other):
13286 
    return not (self == other)
13287 
 
13288 
class deleteBanner_args:
13289 
  """
13290 
  Attributes:
13291 
   - bannerName
9155 kshitij.so 13292 
   - bannerType
6850 kshitij.so 13293 
  """
13294 
 
13295 
  thrift_spec = (
13296 
    None, # 0
13297 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13298 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13299 
  )
13300 
 
9155 kshitij.so 13301 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13302 
    self.bannerName = bannerName
9155 kshitij.so 13303 
    self.bannerType = bannerType
6850 kshitij.so 13304 
 
13305 
  def read(self, iprot):
13306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13308 
      return
13309 
    iprot.readStructBegin()
13310 
    while True:
13311 
      (fname, ftype, fid) = iprot.readFieldBegin()
13312 
      if ftype == TType.STOP:
13313 
        break
13314 
      if fid == 1:
13315 
        if ftype == TType.STRING:
13316 
          self.bannerName = iprot.readString();
13317 
        else:
13318 
          iprot.skip(ftype)
9155 kshitij.so 13319 
      elif fid == 2:
13320 
        if ftype == TType.I32:
13321 
          self.bannerType = iprot.readI32();
13322 
        else:
13323 
          iprot.skip(ftype)
6850 kshitij.so 13324 
      else:
13325 
        iprot.skip(ftype)
13326 
      iprot.readFieldEnd()
13327 
    iprot.readStructEnd()
13328 
 
13329 
  def write(self, oprot):
13330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13332 
      return
13333 
    oprot.writeStructBegin('deleteBanner_args')
13334 
    if self.bannerName is not None:
13335 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13336 
      oprot.writeString(self.bannerName)
13337 
      oprot.writeFieldEnd()
9155 kshitij.so 13338 
    if self.bannerType is not None:
13339 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13340 
      oprot.writeI32(self.bannerType)
13341 
      oprot.writeFieldEnd()
6850 kshitij.so 13342 
    oprot.writeFieldStop()
13343 
    oprot.writeStructEnd()
13344 
 
13345 
  def validate(self):
13346 
    return
13347 
 
13348 
 
13349 
  def __repr__(self):
13350 
    L = ['%s=%r' % (key, value)
13351 
      for key, value in self.__dict__.iteritems()]
13352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13353 
 
13354 
  def __eq__(self, other):
13355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13356 
 
13357 
  def __ne__(self, other):
13358 
    return not (self == other)
13359 
 
13360 
class deleteBanner_result:
13361 
  """
13362 
  Attributes:
13363 
   - success
13364 
  """
13365 
 
13366 
  thrift_spec = (
13367 
    (0, TType.BOOL, 'success', None, None, ), # 0
13368 
  )
13369 
 
13370 
  def __init__(self, success=None,):
13371 
    self.success = success
13372 
 
13373 
  def read(self, iprot):
13374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13376 
      return
13377 
    iprot.readStructBegin()
13378 
    while True:
13379 
      (fname, ftype, fid) = iprot.readFieldBegin()
13380 
      if ftype == TType.STOP:
13381 
        break
13382 
      if fid == 0:
13383 
        if ftype == TType.BOOL:
13384 
          self.success = iprot.readBool();
13385 
        else:
13386 
          iprot.skip(ftype)
13387 
      else:
13388 
        iprot.skip(ftype)
13389 
      iprot.readFieldEnd()
13390 
    iprot.readStructEnd()
13391 
 
13392 
  def write(self, oprot):
13393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13395 
      return
13396 
    oprot.writeStructBegin('deleteBanner_result')
13397 
    if self.success is not None:
13398 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13399 
      oprot.writeBool(self.success)
13400 
      oprot.writeFieldEnd()
13401 
    oprot.writeFieldStop()
13402 
    oprot.writeStructEnd()
13403 
 
13404 
  def validate(self):
13405 
    return
13406 
 
13407 
 
13408 
  def __repr__(self):
13409 
    L = ['%s=%r' % (key, value)
13410 
      for key, value in self.__dict__.iteritems()]
13411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13412 
 
13413 
  def __eq__(self, other):
13414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13415 
 
13416 
  def __ne__(self, other):
13417 
    return not (self == other)
13418 
 
13419 
class getBannerDetails_args:
13420 
  """
13421 
  Attributes:
13422 
   - bannerName
9155 kshitij.so 13423 
   - bannerType
6850 kshitij.so 13424 
  """
13425 
 
13426 
  thrift_spec = (
13427 
    None, # 0
13428 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13429 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13430 
  )
13431 
 
9155 kshitij.so 13432 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13433 
    self.bannerName = bannerName
9155 kshitij.so 13434 
    self.bannerType = bannerType
6850 kshitij.so 13435 
 
13436 
  def read(self, iprot):
13437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13439 
      return
13440 
    iprot.readStructBegin()
13441 
    while True:
13442 
      (fname, ftype, fid) = iprot.readFieldBegin()
13443 
      if ftype == TType.STOP:
13444 
        break
13445 
      if fid == 1:
13446 
        if ftype == TType.STRING:
13447 
          self.bannerName = iprot.readString();
13448 
        else:
13449 
          iprot.skip(ftype)
9155 kshitij.so 13450 
      elif fid == 2:
13451 
        if ftype == TType.I32:
13452 
          self.bannerType = iprot.readI32();
13453 
        else:
13454 
          iprot.skip(ftype)
6850 kshitij.so 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('getBannerDetails_args')
13465 
    if self.bannerName is not None:
13466 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13467 
      oprot.writeString(self.bannerName)
13468 
      oprot.writeFieldEnd()
9155 kshitij.so 13469 
    if self.bannerType is not None:
13470 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13471 
      oprot.writeI32(self.bannerType)
13472 
      oprot.writeFieldEnd()
6850 kshitij.so 13473 
    oprot.writeFieldStop()
13474 
    oprot.writeStructEnd()
13475 
 
13476 
  def validate(self):
13477 
    return
13478 
 
13479 
 
13480 
  def __repr__(self):
13481 
    L = ['%s=%r' % (key, value)
13482 
      for key, value in self.__dict__.iteritems()]
13483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13484 
 
13485 
  def __eq__(self, other):
13486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13487 
 
13488 
  def __ne__(self, other):
13489 
    return not (self == other)
13490 
 
13491 
class getBannerDetails_result:
13492 
  """
13493 
  Attributes:
13494 
   - success
13495 
  """
13496 
 
13497 
  thrift_spec = (
13498 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
13499 
  )
13500 
 
13501 
  def __init__(self, success=None,):
13502 
    self.success = success
13503 
 
13504 
  def read(self, iprot):
13505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13507 
      return
13508 
    iprot.readStructBegin()
13509 
    while True:
13510 
      (fname, ftype, fid) = iprot.readFieldBegin()
13511 
      if ftype == TType.STOP:
13512 
        break
13513 
      if fid == 0:
13514 
        if ftype == TType.STRUCT:
13515 
          self.success = Banner()
13516 
          self.success.read(iprot)
13517 
        else:
13518 
          iprot.skip(ftype)
13519 
      else:
13520 
        iprot.skip(ftype)
13521 
      iprot.readFieldEnd()
13522 
    iprot.readStructEnd()
13523 
 
13524 
  def write(self, oprot):
13525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13527 
      return
13528 
    oprot.writeStructBegin('getBannerDetails_result')
13529 
    if self.success is not None:
13530 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13531 
      self.success.write(oprot)
13532 
      oprot.writeFieldEnd()
13533 
    oprot.writeFieldStop()
13534 
    oprot.writeStructEnd()
13535 
 
13536 
  def validate(self):
13537 
    return
13538 
 
13539 
 
13540 
  def __repr__(self):
13541 
    L = ['%s=%r' % (key, value)
13542 
      for key, value in self.__dict__.iteritems()]
13543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13544 
 
13545 
  def __eq__(self, other):
13546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13547 
 
13548 
  def __ne__(self, other):
13549 
    return not (self == other)
13550 
 
13551 
class getActiveBanners_args:
13552 
 
13553 
  thrift_spec = (
13554 
  )
13555 
 
13556 
  def read(self, iprot):
13557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13559 
      return
13560 
    iprot.readStructBegin()
13561 
    while True:
13562 
      (fname, ftype, fid) = iprot.readFieldBegin()
13563 
      if ftype == TType.STOP:
13564 
        break
13565 
      else:
13566 
        iprot.skip(ftype)
13567 
      iprot.readFieldEnd()
13568 
    iprot.readStructEnd()
13569 
 
13570 
  def write(self, oprot):
13571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13573 
      return
13574 
    oprot.writeStructBegin('getActiveBanners_args')
13575 
    oprot.writeFieldStop()
13576 
    oprot.writeStructEnd()
13577 
 
13578 
  def validate(self):
13579 
    return
13580 
 
13581 
 
13582 
  def __repr__(self):
13583 
    L = ['%s=%r' % (key, value)
13584 
      for key, value in self.__dict__.iteritems()]
13585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13586 
 
13587 
  def __eq__(self, other):
13588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13589 
 
13590 
  def __ne__(self, other):
13591 
    return not (self == other)
13592 
 
13593 
class getActiveBanners_result:
13594 
  """
13595 
  Attributes:
13596 
   - success
13597 
  """
13598 
 
13599 
  thrift_spec = (
8579 kshitij.so 13600 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 13601 
  )
13602 
 
13603 
  def __init__(self, success=None,):
13604 
    self.success = success
13605 
 
13606 
  def read(self, iprot):
13607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13609 
      return
13610 
    iprot.readStructBegin()
13611 
    while True:
13612 
      (fname, ftype, fid) = iprot.readFieldBegin()
13613 
      if ftype == TType.STOP:
13614 
        break
13615 
      if fid == 0:
8579 kshitij.so 13616 
        if ftype == TType.MAP:
13617 
          self.success = {}
8590 kshitij.so 13618 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
13619 
          for _i206 in xrange(_size202):
13620 
            _key207 = iprot.readString();
13621 
            _val208 = []
13622 
            (_etype212, _size209) = iprot.readListBegin()
13623 
            for _i213 in xrange(_size209):
13624 
              _elem214 = Banner()
13625 
              _elem214.read(iprot)
13626 
              _val208.append(_elem214)
8579 kshitij.so 13627 
            iprot.readListEnd()
8590 kshitij.so 13628 
            self.success[_key207] = _val208
8579 kshitij.so 13629 
          iprot.readMapEnd()
6850 kshitij.so 13630 
        else:
13631 
          iprot.skip(ftype)
13632 
      else:
13633 
        iprot.skip(ftype)
13634 
      iprot.readFieldEnd()
13635 
    iprot.readStructEnd()
13636 
 
13637 
  def write(self, oprot):
13638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13640 
      return
13641 
    oprot.writeStructBegin('getActiveBanners_result')
13642 
    if self.success is not None:
8579 kshitij.so 13643 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13644 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 13645 
      for kiter215,viter216 in self.success.items():
13646 
        oprot.writeString(kiter215)
13647 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
13648 
        for iter217 in viter216:
13649 
          iter217.write(oprot)
8579 kshitij.so 13650 
        oprot.writeListEnd()
13651 
      oprot.writeMapEnd()
6850 kshitij.so 13652 
      oprot.writeFieldEnd()
13653 
    oprot.writeFieldStop()
13654 
    oprot.writeStructEnd()
13655 
 
13656 
  def validate(self):
13657 
    return
13658 
 
13659 
 
13660 
  def __repr__(self):
13661 
    L = ['%s=%r' % (key, value)
13662 
      for key, value in self.__dict__.iteritems()]
13663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13664 
 
13665 
  def __eq__(self, other):
13666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13667 
 
13668 
  def __ne__(self, other):
13669 
    return not (self == other)
13670 
 
6849 kshitij.so 13671 
class addBannerMap_args:
13672 
  """
13673 
  Attributes:
8579 kshitij.so 13674 
   - bannerMaps
6849 kshitij.so 13675 
  """
13676 
 
13677 
  thrift_spec = (
13678 
    None, # 0
8579 kshitij.so 13679 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 13680 
  )
13681 
 
8579 kshitij.so 13682 
  def __init__(self, bannerMaps=None,):
13683 
    self.bannerMaps = bannerMaps
6849 kshitij.so 13684 
 
13685 
  def read(self, iprot):
13686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13688 
      return
13689 
    iprot.readStructBegin()
13690 
    while True:
13691 
      (fname, ftype, fid) = iprot.readFieldBegin()
13692 
      if ftype == TType.STOP:
13693 
        break
13694 
      if fid == 1:
8579 kshitij.so 13695 
        if ftype == TType.LIST:
13696 
          self.bannerMaps = []
8590 kshitij.so 13697 
          (_etype221, _size218) = iprot.readListBegin()
13698 
          for _i222 in xrange(_size218):
13699 
            _elem223 = BannerMap()
13700 
            _elem223.read(iprot)
13701 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 13702 
          iprot.readListEnd()
6849 kshitij.so 13703 
        else:
13704 
          iprot.skip(ftype)
8579 kshitij.so 13705 
      else:
13706 
        iprot.skip(ftype)
13707 
      iprot.readFieldEnd()
13708 
    iprot.readStructEnd()
13709 
 
13710 
  def write(self, oprot):
13711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13713 
      return
13714 
    oprot.writeStructBegin('addBannerMap_args')
13715 
    if self.bannerMaps is not None:
13716 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
13717 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 13718 
      for iter224 in self.bannerMaps:
13719 
        iter224.write(oprot)
8579 kshitij.so 13720 
      oprot.writeListEnd()
13721 
      oprot.writeFieldEnd()
13722 
    oprot.writeFieldStop()
13723 
    oprot.writeStructEnd()
13724 
 
13725 
  def validate(self):
13726 
    return
13727 
 
13728 
 
13729 
  def __repr__(self):
13730 
    L = ['%s=%r' % (key, value)
13731 
      for key, value in self.__dict__.iteritems()]
13732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13733 
 
13734 
  def __eq__(self, other):
13735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13736 
 
13737 
  def __ne__(self, other):
13738 
    return not (self == other)
13739 
 
13740 
class addBannerMap_result:
13741 
  """
13742 
  Attributes:
13743 
   - success
13744 
  """
13745 
 
13746 
  thrift_spec = (
13747 
    (0, TType.BOOL, 'success', None, None, ), # 0
13748 
  )
13749 
 
13750 
  def __init__(self, success=None,):
13751 
    self.success = success
13752 
 
13753 
  def read(self, iprot):
13754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13756 
      return
13757 
    iprot.readStructBegin()
13758 
    while True:
13759 
      (fname, ftype, fid) = iprot.readFieldBegin()
13760 
      if ftype == TType.STOP:
13761 
        break
13762 
      if fid == 0:
13763 
        if ftype == TType.BOOL:
13764 
          self.success = iprot.readBool();
6849 kshitij.so 13765 
        else:
13766 
          iprot.skip(ftype)
8579 kshitij.so 13767 
      else:
13768 
        iprot.skip(ftype)
13769 
      iprot.readFieldEnd()
13770 
    iprot.readStructEnd()
13771 
 
13772 
  def write(self, oprot):
13773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13775 
      return
13776 
    oprot.writeStructBegin('addBannerMap_result')
13777 
    if self.success is not None:
13778 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13779 
      oprot.writeBool(self.success)
13780 
      oprot.writeFieldEnd()
13781 
    oprot.writeFieldStop()
13782 
    oprot.writeStructEnd()
13783 
 
13784 
  def validate(self):
13785 
    return
13786 
 
13787 
 
13788 
  def __repr__(self):
13789 
    L = ['%s=%r' % (key, value)
13790 
      for key, value in self.__dict__.iteritems()]
13791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13792 
 
13793 
  def __eq__(self, other):
13794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13795 
 
13796 
  def __ne__(self, other):
13797 
    return not (self == other)
13798 
 
13799 
class updateBannerMap_args:
13800 
  """
13801 
  Attributes:
13802 
   - bannerMap
13803 
  """
13804 
 
13805 
  thrift_spec = (
13806 
    None, # 0
13807 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
13808 
  )
13809 
 
13810 
  def __init__(self, bannerMap=None,):
13811 
    self.bannerMap = bannerMap
13812 
 
13813 
  def read(self, iprot):
13814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13816 
      return
13817 
    iprot.readStructBegin()
13818 
    while True:
13819 
      (fname, ftype, fid) = iprot.readFieldBegin()
13820 
      if ftype == TType.STOP:
13821 
        break
13822 
      if fid == 1:
13823 
        if ftype == TType.STRUCT:
13824 
          self.bannerMap = BannerMap()
13825 
          self.bannerMap.read(iprot)
6849 kshitij.so 13826 
        else:
13827 
          iprot.skip(ftype)
13828 
      else:
13829 
        iprot.skip(ftype)
13830 
      iprot.readFieldEnd()
13831 
    iprot.readStructEnd()
13832 
 
13833 
  def write(self, oprot):
13834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13836 
      return
8579 kshitij.so 13837 
    oprot.writeStructBegin('updateBannerMap_args')
13838 
    if self.bannerMap is not None:
13839 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
13840 
      self.bannerMap.write(oprot)
6849 kshitij.so 13841 
      oprot.writeFieldEnd()
13842 
    oprot.writeFieldStop()
13843 
    oprot.writeStructEnd()
13844 
 
13845 
  def validate(self):
13846 
    return
13847 
 
13848 
 
13849 
  def __repr__(self):
13850 
    L = ['%s=%r' % (key, value)
13851 
      for key, value in self.__dict__.iteritems()]
13852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13853 
 
13854 
  def __eq__(self, other):
13855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13856 
 
13857 
  def __ne__(self, other):
13858 
    return not (self == other)
13859 
 
8579 kshitij.so 13860 
class updateBannerMap_result:
6849 kshitij.so 13861 
  """
13862 
  Attributes:
13863 
   - success
13864 
  """
13865 
 
13866 
  thrift_spec = (
13867 
    (0, TType.BOOL, 'success', None, None, ), # 0
13868 
  )
13869 
 
13870 
  def __init__(self, success=None,):
13871 
    self.success = success
13872 
 
13873 
  def read(self, iprot):
13874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13876 
      return
13877 
    iprot.readStructBegin()
13878 
    while True:
13879 
      (fname, ftype, fid) = iprot.readFieldBegin()
13880 
      if ftype == TType.STOP:
13881 
        break
13882 
      if fid == 0:
13883 
        if ftype == TType.BOOL:
13884 
          self.success = iprot.readBool();
13885 
        else:
13886 
          iprot.skip(ftype)
13887 
      else:
13888 
        iprot.skip(ftype)
13889 
      iprot.readFieldEnd()
13890 
    iprot.readStructEnd()
13891 
 
13892 
  def write(self, oprot):
13893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13895 
      return
8579 kshitij.so 13896 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 13897 
    if self.success is not None:
13898 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13899 
      oprot.writeBool(self.success)
13900 
      oprot.writeFieldEnd()
13901 
    oprot.writeFieldStop()
13902 
    oprot.writeStructEnd()
13903 
 
13904 
  def validate(self):
13905 
    return
13906 
 
13907 
 
13908 
  def __repr__(self):
13909 
    L = ['%s=%r' % (key, value)
13910 
      for key, value in self.__dict__.iteritems()]
13911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13912 
 
13913 
  def __eq__(self, other):
13914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13915 
 
13916 
  def __ne__(self, other):
13917 
    return not (self == other)
13918 
 
13919 
class deleteBannerMap_args:
13920 
  """
13921 
  Attributes:
13922 
   - bannerName
13923 
  """
13924 
 
13925 
  thrift_spec = (
13926 
    None, # 0
13927 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
13928 
  )
13929 
 
13930 
  def __init__(self, bannerName=None,):
13931 
    self.bannerName = bannerName
13932 
 
13933 
  def read(self, iprot):
13934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13936 
      return
13937 
    iprot.readStructBegin()
13938 
    while True:
13939 
      (fname, ftype, fid) = iprot.readFieldBegin()
13940 
      if ftype == TType.STOP:
13941 
        break
13942 
      if fid == 1:
13943 
        if ftype == TType.STRING:
13944 
          self.bannerName = iprot.readString();
13945 
        else:
13946 
          iprot.skip(ftype)
13947 
      else:
13948 
        iprot.skip(ftype)
13949 
      iprot.readFieldEnd()
13950 
    iprot.readStructEnd()
13951 
 
13952 
  def write(self, oprot):
13953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13955 
      return
13956 
    oprot.writeStructBegin('deleteBannerMap_args')
13957 
    if self.bannerName is not None:
13958 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13959 
      oprot.writeString(self.bannerName)
13960 
      oprot.writeFieldEnd()
13961 
    oprot.writeFieldStop()
13962 
    oprot.writeStructEnd()
13963 
 
13964 
  def validate(self):
13965 
    return
13966 
 
13967 
 
13968 
  def __repr__(self):
13969 
    L = ['%s=%r' % (key, value)
13970 
      for key, value in self.__dict__.iteritems()]
13971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13972 
 
13973 
  def __eq__(self, other):
13974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13975 
 
13976 
  def __ne__(self, other):
13977 
    return not (self == other)
13978 
 
13979 
class deleteBannerMap_result:
13980 
  """
13981 
  Attributes:
13982 
   - success
13983 
  """
13984 
 
13985 
  thrift_spec = (
13986 
    (0, TType.BOOL, 'success', None, None, ), # 0
13987 
  )
13988 
 
13989 
  def __init__(self, success=None,):
13990 
    self.success = success
13991 
 
13992 
  def read(self, iprot):
13993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13995 
      return
13996 
    iprot.readStructBegin()
13997 
    while True:
13998 
      (fname, ftype, fid) = iprot.readFieldBegin()
13999 
      if ftype == TType.STOP:
14000 
        break
14001 
      if fid == 0:
14002 
        if ftype == TType.BOOL:
14003 
          self.success = iprot.readBool();
14004 
        else:
14005 
          iprot.skip(ftype)
14006 
      else:
14007 
        iprot.skip(ftype)
14008 
      iprot.readFieldEnd()
14009 
    iprot.readStructEnd()
14010 
 
14011 
  def write(self, oprot):
14012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14014 
      return
14015 
    oprot.writeStructBegin('deleteBannerMap_result')
14016 
    if self.success is not None:
14017 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14018 
      oprot.writeBool(self.success)
14019 
      oprot.writeFieldEnd()
14020 
    oprot.writeFieldStop()
14021 
    oprot.writeStructEnd()
14022 
 
14023 
  def validate(self):
14024 
    return
14025 
 
14026 
 
14027 
  def __repr__(self):
14028 
    L = ['%s=%r' % (key, value)
14029 
      for key, value in self.__dict__.iteritems()]
14030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14031 
 
14032 
  def __eq__(self, other):
14033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14034 
 
14035 
  def __ne__(self, other):
14036 
    return not (self == other)
14037 
 
14038 
class getBannerMapDetails_args:
14039 
  """
14040 
  Attributes:
14041 
   - bannerName
9155 kshitij.so 14042 
   - bannerType
6849 kshitij.so 14043 
  """
14044 
 
14045 
  thrift_spec = (
14046 
    None, # 0
14047 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14048 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 14049 
  )
14050 
 
9155 kshitij.so 14051 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 14052 
    self.bannerName = bannerName
9155 kshitij.so 14053 
    self.bannerType = bannerType
6849 kshitij.so 14054 
 
14055 
  def read(self, iprot):
14056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14058 
      return
14059 
    iprot.readStructBegin()
14060 
    while True:
14061 
      (fname, ftype, fid) = iprot.readFieldBegin()
14062 
      if ftype == TType.STOP:
14063 
        break
14064 
      if fid == 1:
14065 
        if ftype == TType.STRING:
14066 
          self.bannerName = iprot.readString();
14067 
        else:
14068 
          iprot.skip(ftype)
9155 kshitij.so 14069 
      elif fid == 2:
14070 
        if ftype == TType.I32:
14071 
          self.bannerType = iprot.readI32();
14072 
        else:
14073 
          iprot.skip(ftype)
6849 kshitij.so 14074 
      else:
14075 
        iprot.skip(ftype)
14076 
      iprot.readFieldEnd()
14077 
    iprot.readStructEnd()
14078 
 
14079 
  def write(self, oprot):
14080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14082 
      return
14083 
    oprot.writeStructBegin('getBannerMapDetails_args')
14084 
    if self.bannerName is not None:
14085 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14086 
      oprot.writeString(self.bannerName)
14087 
      oprot.writeFieldEnd()
9155 kshitij.so 14088 
    if self.bannerType is not None:
14089 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14090 
      oprot.writeI32(self.bannerType)
14091 
      oprot.writeFieldEnd()
6849 kshitij.so 14092 
    oprot.writeFieldStop()
14093 
    oprot.writeStructEnd()
14094 
 
14095 
  def validate(self):
14096 
    return
14097 
 
14098 
 
14099 
  def __repr__(self):
14100 
    L = ['%s=%r' % (key, value)
14101 
      for key, value in self.__dict__.iteritems()]
14102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14103 
 
14104 
  def __eq__(self, other):
14105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14106 
 
14107 
  def __ne__(self, other):
14108 
    return not (self == other)
14109 
 
14110 
class getBannerMapDetails_result:
14111 
  """
14112 
  Attributes:
14113 
   - success
14114 
  """
14115 
 
14116 
  thrift_spec = (
14117 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
14118 
  )
14119 
 
14120 
  def __init__(self, success=None,):
14121 
    self.success = success
14122 
 
14123 
  def read(self, iprot):
14124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14126 
      return
14127 
    iprot.readStructBegin()
14128 
    while True:
14129 
      (fname, ftype, fid) = iprot.readFieldBegin()
14130 
      if ftype == TType.STOP:
14131 
        break
14132 
      if fid == 0:
14133 
        if ftype == TType.LIST:
14134 
          self.success = []
8590 kshitij.so 14135 
          (_etype228, _size225) = iprot.readListBegin()
14136 
          for _i229 in xrange(_size225):
14137 
            _elem230 = BannerMap()
14138 
            _elem230.read(iprot)
14139 
            self.success.append(_elem230)
6849 kshitij.so 14140 
          iprot.readListEnd()
14141 
        else:
14142 
          iprot.skip(ftype)
14143 
      else:
14144 
        iprot.skip(ftype)
14145 
      iprot.readFieldEnd()
14146 
    iprot.readStructEnd()
14147 
 
14148 
  def write(self, oprot):
14149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14151 
      return
14152 
    oprot.writeStructBegin('getBannerMapDetails_result')
14153 
    if self.success is not None:
14154 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14155 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14156 
      for iter231 in self.success:
14157 
        iter231.write(oprot)
6849 kshitij.so 14158 
      oprot.writeListEnd()
14159 
      oprot.writeFieldEnd()
14160 
    oprot.writeFieldStop()
14161 
    oprot.writeStructEnd()
14162 
 
14163 
  def validate(self):
14164 
    return
14165 
 
14166 
 
14167 
  def __repr__(self):
14168 
    L = ['%s=%r' % (key, value)
14169 
      for key, value in self.__dict__.iteritems()]
14170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14171 
 
14172 
  def __eq__(self, other):
14173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14174 
 
14175 
  def __ne__(self, other):
14176 
    return not (self == other)
14177 
 
8579 kshitij.so 14178 
class addBannerUri_args:
14179 
  """
14180 
  Attributes:
14181 
   - bannerUriMappings
14182 
  """
14183 
 
14184 
  thrift_spec = (
14185 
    None, # 0
14186 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
14187 
  )
14188 
 
14189 
  def __init__(self, bannerUriMappings=None,):
14190 
    self.bannerUriMappings = bannerUriMappings
14191 
 
14192 
  def read(self, iprot):
14193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14195 
      return
14196 
    iprot.readStructBegin()
14197 
    while True:
14198 
      (fname, ftype, fid) = iprot.readFieldBegin()
14199 
      if ftype == TType.STOP:
14200 
        break
14201 
      if fid == 1:
14202 
        if ftype == TType.LIST:
14203 
          self.bannerUriMappings = []
8590 kshitij.so 14204 
          (_etype235, _size232) = iprot.readListBegin()
14205 
          for _i236 in xrange(_size232):
14206 
            _elem237 = BannerUriMapping()
14207 
            _elem237.read(iprot)
14208 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 14209 
          iprot.readListEnd()
14210 
        else:
14211 
          iprot.skip(ftype)
14212 
      else:
14213 
        iprot.skip(ftype)
14214 
      iprot.readFieldEnd()
14215 
    iprot.readStructEnd()
14216 
 
14217 
  def write(self, oprot):
14218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14220 
      return
14221 
    oprot.writeStructBegin('addBannerUri_args')
14222 
    if self.bannerUriMappings is not None:
14223 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
14224 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 14225 
      for iter238 in self.bannerUriMappings:
14226 
        iter238.write(oprot)
8579 kshitij.so 14227 
      oprot.writeListEnd()
14228 
      oprot.writeFieldEnd()
14229 
    oprot.writeFieldStop()
14230 
    oprot.writeStructEnd()
14231 
 
14232 
  def validate(self):
14233 
    return
14234 
 
14235 
 
14236 
  def __repr__(self):
14237 
    L = ['%s=%r' % (key, value)
14238 
      for key, value in self.__dict__.iteritems()]
14239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14240 
 
14241 
  def __eq__(self, other):
14242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14243 
 
14244 
  def __ne__(self, other):
14245 
    return not (self == other)
14246 
 
14247 
class addBannerUri_result:
14248 
 
14249 
  thrift_spec = (
14250 
  )
14251 
 
14252 
  def read(self, iprot):
14253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14255 
      return
14256 
    iprot.readStructBegin()
14257 
    while True:
14258 
      (fname, ftype, fid) = iprot.readFieldBegin()
14259 
      if ftype == TType.STOP:
14260 
        break
14261 
      else:
14262 
        iprot.skip(ftype)
14263 
      iprot.readFieldEnd()
14264 
    iprot.readStructEnd()
14265 
 
14266 
  def write(self, oprot):
14267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14269 
      return
14270 
    oprot.writeStructBegin('addBannerUri_result')
14271 
    oprot.writeFieldStop()
14272 
    oprot.writeStructEnd()
14273 
 
14274 
  def validate(self):
14275 
    return
14276 
 
14277 
 
14278 
  def __repr__(self):
14279 
    L = ['%s=%r' % (key, value)
14280 
      for key, value in self.__dict__.iteritems()]
14281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14282 
 
14283 
  def __eq__(self, other):
14284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14285 
 
14286 
  def __ne__(self, other):
14287 
    return not (self == other)
14288 
 
14289 
class getUriMapping_args:
14290 
  """
14291 
  Attributes:
14292 
   - bannerName
9155 kshitij.so 14293 
   - bannerType
8579 kshitij.so 14294 
  """
14295 
 
14296 
  thrift_spec = (
14297 
    None, # 0
14298 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14299 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 14300 
  )
14301 
 
9155 kshitij.so 14302 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 14303 
    self.bannerName = bannerName
9155 kshitij.so 14304 
    self.bannerType = bannerType
8579 kshitij.so 14305 
 
14306 
  def read(self, iprot):
14307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14309 
      return
14310 
    iprot.readStructBegin()
14311 
    while True:
14312 
      (fname, ftype, fid) = iprot.readFieldBegin()
14313 
      if ftype == TType.STOP:
14314 
        break
14315 
      if fid == 1:
14316 
        if ftype == TType.STRING:
14317 
          self.bannerName = iprot.readString();
14318 
        else:
14319 
          iprot.skip(ftype)
9155 kshitij.so 14320 
      elif fid == 2:
14321 
        if ftype == TType.I32:
14322 
          self.bannerType = iprot.readI32();
14323 
        else:
14324 
          iprot.skip(ftype)
8579 kshitij.so 14325 
      else:
14326 
        iprot.skip(ftype)
14327 
      iprot.readFieldEnd()
14328 
    iprot.readStructEnd()
14329 
 
14330 
  def write(self, oprot):
14331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14333 
      return
14334 
    oprot.writeStructBegin('getUriMapping_args')
14335 
    if self.bannerName is not None:
14336 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14337 
      oprot.writeString(self.bannerName)
14338 
      oprot.writeFieldEnd()
9155 kshitij.so 14339 
    if self.bannerType is not None:
14340 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14341 
      oprot.writeI32(self.bannerType)
14342 
      oprot.writeFieldEnd()
8579 kshitij.so 14343 
    oprot.writeFieldStop()
14344 
    oprot.writeStructEnd()
14345 
 
14346 
  def validate(self):
14347 
    return
14348 
 
14349 
 
14350 
  def __repr__(self):
14351 
    L = ['%s=%r' % (key, value)
14352 
      for key, value in self.__dict__.iteritems()]
14353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14354 
 
14355 
  def __eq__(self, other):
14356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14357 
 
14358 
  def __ne__(self, other):
14359 
    return not (self == other)
14360 
 
14361 
class getUriMapping_result:
14362 
  """
14363 
  Attributes:
14364 
   - success
14365 
  """
14366 
 
14367 
  thrift_spec = (
14368 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
14369 
  )
14370 
 
14371 
  def __init__(self, success=None,):
14372 
    self.success = success
14373 
 
14374 
  def read(self, iprot):
14375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14377 
      return
14378 
    iprot.readStructBegin()
14379 
    while True:
14380 
      (fname, ftype, fid) = iprot.readFieldBegin()
14381 
      if ftype == TType.STOP:
14382 
        break
14383 
      if fid == 0:
14384 
        if ftype == TType.LIST:
14385 
          self.success = []
8590 kshitij.so 14386 
          (_etype242, _size239) = iprot.readListBegin()
14387 
          for _i243 in xrange(_size239):
14388 
            _elem244 = BannerUriMapping()
14389 
            _elem244.read(iprot)
14390 
            self.success.append(_elem244)
8579 kshitij.so 14391 
          iprot.readListEnd()
14392 
        else:
14393 
          iprot.skip(ftype)
14394 
      else:
14395 
        iprot.skip(ftype)
14396 
      iprot.readFieldEnd()
14397 
    iprot.readStructEnd()
14398 
 
14399 
  def write(self, oprot):
14400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14402 
      return
14403 
    oprot.writeStructBegin('getUriMapping_result')
14404 
    if self.success is not None:
14405 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14406 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14407 
      for iter245 in self.success:
14408 
        iter245.write(oprot)
8579 kshitij.so 14409 
      oprot.writeListEnd()
14410 
      oprot.writeFieldEnd()
14411 
    oprot.writeFieldStop()
14412 
    oprot.writeStructEnd()
14413 
 
14414 
  def validate(self):
14415 
    return
14416 
 
14417 
 
14418 
  def __repr__(self):
14419 
    L = ['%s=%r' % (key, value)
14420 
      for key, value in self.__dict__.iteritems()]
14421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14422 
 
14423 
  def __eq__(self, other):
14424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14425 
 
14426 
  def __ne__(self, other):
14427 
    return not (self == other)
14428 
 
14429 
class addCampaign_args:
14430 
  """
14431 
  Attributes:
14432 
   - campaign
14433 
  """
14434 
 
14435 
  thrift_spec = (
14436 
    None, # 0
14437 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
14438 
  )
14439 
 
14440 
  def __init__(self, campaign=None,):
14441 
    self.campaign = campaign
14442 
 
14443 
  def read(self, iprot):
14444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14446 
      return
14447 
    iprot.readStructBegin()
14448 
    while True:
14449 
      (fname, ftype, fid) = iprot.readFieldBegin()
14450 
      if ftype == TType.STOP:
14451 
        break
14452 
      if fid == 1:
14453 
        if ftype == TType.STRUCT:
14454 
          self.campaign = Campaign()
14455 
          self.campaign.read(iprot)
14456 
        else:
14457 
          iprot.skip(ftype)
14458 
      else:
14459 
        iprot.skip(ftype)
14460 
      iprot.readFieldEnd()
14461 
    iprot.readStructEnd()
14462 
 
14463 
  def write(self, oprot):
14464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14466 
      return
14467 
    oprot.writeStructBegin('addCampaign_args')
14468 
    if self.campaign is not None:
14469 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
14470 
      self.campaign.write(oprot)
14471 
      oprot.writeFieldEnd()
14472 
    oprot.writeFieldStop()
14473 
    oprot.writeStructEnd()
14474 
 
14475 
  def validate(self):
14476 
    return
14477 
 
14478 
 
14479 
  def __repr__(self):
14480 
    L = ['%s=%r' % (key, value)
14481 
      for key, value in self.__dict__.iteritems()]
14482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14483 
 
14484 
  def __eq__(self, other):
14485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14486 
 
14487 
  def __ne__(self, other):
14488 
    return not (self == other)
14489 
 
14490 
class addCampaign_result:
14491 
 
14492 
  thrift_spec = (
14493 
  )
14494 
 
14495 
  def read(self, iprot):
14496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14498 
      return
14499 
    iprot.readStructBegin()
14500 
    while True:
14501 
      (fname, ftype, fid) = iprot.readFieldBegin()
14502 
      if ftype == TType.STOP:
14503 
        break
14504 
      else:
14505 
        iprot.skip(ftype)
14506 
      iprot.readFieldEnd()
14507 
    iprot.readStructEnd()
14508 
 
14509 
  def write(self, oprot):
14510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14512 
      return
14513 
    oprot.writeStructBegin('addCampaign_result')
14514 
    oprot.writeFieldStop()
14515 
    oprot.writeStructEnd()
14516 
 
14517 
  def validate(self):
14518 
    return
14519 
 
14520 
 
14521 
  def __repr__(self):
14522 
    L = ['%s=%r' % (key, value)
14523 
      for key, value in self.__dict__.iteritems()]
14524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14525 
 
14526 
  def __eq__(self, other):
14527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14528 
 
14529 
  def __ne__(self, other):
14530 
    return not (self == other)
14531 
 
14532 
class getCampaigns_args:
14533 
  """
14534 
  Attributes:
14535 
   - campaignName
14536 
  """
14537 
 
14538 
  thrift_spec = (
14539 
    None, # 0
14540 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
14541 
  )
14542 
 
14543 
  def __init__(self, campaignName=None,):
14544 
    self.campaignName = campaignName
14545 
 
14546 
  def read(self, iprot):
14547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14549 
      return
14550 
    iprot.readStructBegin()
14551 
    while True:
14552 
      (fname, ftype, fid) = iprot.readFieldBegin()
14553 
      if ftype == TType.STOP:
14554 
        break
14555 
      if fid == 1:
14556 
        if ftype == TType.STRING:
14557 
          self.campaignName = iprot.readString();
14558 
        else:
14559 
          iprot.skip(ftype)
14560 
      else:
14561 
        iprot.skip(ftype)
14562 
      iprot.readFieldEnd()
14563 
    iprot.readStructEnd()
14564 
 
14565 
  def write(self, oprot):
14566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14568 
      return
14569 
    oprot.writeStructBegin('getCampaigns_args')
14570 
    if self.campaignName is not None:
14571 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
14572 
      oprot.writeString(self.campaignName)
14573 
      oprot.writeFieldEnd()
14574 
    oprot.writeFieldStop()
14575 
    oprot.writeStructEnd()
14576 
 
14577 
  def validate(self):
14578 
    return
14579 
 
14580 
 
14581 
  def __repr__(self):
14582 
    L = ['%s=%r' % (key, value)
14583 
      for key, value in self.__dict__.iteritems()]
14584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14585 
 
14586 
  def __eq__(self, other):
14587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14588 
 
14589 
  def __ne__(self, other):
14590 
    return not (self == other)
14591 
 
14592 
class getCampaigns_result:
14593 
  """
14594 
  Attributes:
14595 
   - success
14596 
  """
14597 
 
14598 
  thrift_spec = (
14599 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
14600 
  )
14601 
 
14602 
  def __init__(self, success=None,):
14603 
    self.success = success
14604 
 
14605 
  def read(self, iprot):
14606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14608 
      return
14609 
    iprot.readStructBegin()
14610 
    while True:
14611 
      (fname, ftype, fid) = iprot.readFieldBegin()
14612 
      if ftype == TType.STOP:
14613 
        break
14614 
      if fid == 0:
14615 
        if ftype == TType.LIST:
14616 
          self.success = []
8590 kshitij.so 14617 
          (_etype249, _size246) = iprot.readListBegin()
14618 
          for _i250 in xrange(_size246):
14619 
            _elem251 = Campaign()
14620 
            _elem251.read(iprot)
14621 
            self.success.append(_elem251)
8579 kshitij.so 14622 
          iprot.readListEnd()
14623 
        else:
14624 
          iprot.skip(ftype)
14625 
      else:
14626 
        iprot.skip(ftype)
14627 
      iprot.readFieldEnd()
14628 
    iprot.readStructEnd()
14629 
 
14630 
  def write(self, oprot):
14631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14633 
      return
14634 
    oprot.writeStructBegin('getCampaigns_result')
14635 
    if self.success is not None:
14636 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14637 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14638 
      for iter252 in self.success:
14639 
        iter252.write(oprot)
8579 kshitij.so 14640 
      oprot.writeListEnd()
14641 
      oprot.writeFieldEnd()
14642 
    oprot.writeFieldStop()
14643 
    oprot.writeStructEnd()
14644 
 
14645 
  def validate(self):
14646 
    return
14647 
 
14648 
 
14649 
  def __repr__(self):
14650 
    L = ['%s=%r' % (key, value)
14651 
      for key, value in self.__dict__.iteritems()]
14652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14653 
 
14654 
  def __eq__(self, other):
14655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14656 
 
14657 
  def __ne__(self, other):
14658 
    return not (self == other)
14659 
 
14660 
class deleteCampaign_args:
14661 
  """
14662 
  Attributes:
14663 
   - campaignId
14664 
  """
14665 
 
14666 
  thrift_spec = (
14667 
    None, # 0
14668 
    (1, TType.I64, 'campaignId', None, None, ), # 1
14669 
  )
14670 
 
14671 
  def __init__(self, campaignId=None,):
14672 
    self.campaignId = campaignId
14673 
 
14674 
  def read(self, iprot):
14675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14677 
      return
14678 
    iprot.readStructBegin()
14679 
    while True:
14680 
      (fname, ftype, fid) = iprot.readFieldBegin()
14681 
      if ftype == TType.STOP:
14682 
        break
14683 
      if fid == 1:
14684 
        if ftype == TType.I64:
14685 
          self.campaignId = iprot.readI64();
14686 
        else:
14687 
          iprot.skip(ftype)
14688 
      else:
14689 
        iprot.skip(ftype)
14690 
      iprot.readFieldEnd()
14691 
    iprot.readStructEnd()
14692 
 
14693 
  def write(self, oprot):
14694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14696 
      return
14697 
    oprot.writeStructBegin('deleteCampaign_args')
14698 
    if self.campaignId is not None:
14699 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
14700 
      oprot.writeI64(self.campaignId)
14701 
      oprot.writeFieldEnd()
14702 
    oprot.writeFieldStop()
14703 
    oprot.writeStructEnd()
14704 
 
14705 
  def validate(self):
14706 
    return
14707 
 
14708 
 
14709 
  def __repr__(self):
14710 
    L = ['%s=%r' % (key, value)
14711 
      for key, value in self.__dict__.iteritems()]
14712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14713 
 
14714 
  def __eq__(self, other):
14715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14716 
 
14717 
  def __ne__(self, other):
14718 
    return not (self == other)
14719 
 
14720 
class deleteCampaign_result:
14721 
 
14722 
  thrift_spec = (
14723 
  )
14724 
 
14725 
  def read(self, iprot):
14726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14728 
      return
14729 
    iprot.readStructBegin()
14730 
    while True:
14731 
      (fname, ftype, fid) = iprot.readFieldBegin()
14732 
      if ftype == TType.STOP:
14733 
        break
14734 
      else:
14735 
        iprot.skip(ftype)
14736 
      iprot.readFieldEnd()
14737 
    iprot.readStructEnd()
14738 
 
14739 
  def write(self, oprot):
14740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14742 
      return
14743 
    oprot.writeStructBegin('deleteCampaign_result')
14744 
    oprot.writeFieldStop()
14745 
    oprot.writeStructEnd()
14746 
 
14747 
  def validate(self):
14748 
    return
14749 
 
14750 
 
14751 
  def __repr__(self):
14752 
    L = ['%s=%r' % (key, value)
14753 
      for key, value in self.__dict__.iteritems()]
14754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14755 
 
14756 
  def __eq__(self, other):
14757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14758 
 
14759 
  def __ne__(self, other):
14760 
    return not (self == other)
14761 
 
14762 
class getAllCampaigns_args:
14763 
 
14764 
  thrift_spec = (
14765 
  )
14766 
 
14767 
  def read(self, iprot):
14768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14770 
      return
14771 
    iprot.readStructBegin()
14772 
    while True:
14773 
      (fname, ftype, fid) = iprot.readFieldBegin()
14774 
      if ftype == TType.STOP:
14775 
        break
14776 
      else:
14777 
        iprot.skip(ftype)
14778 
      iprot.readFieldEnd()
14779 
    iprot.readStructEnd()
14780 
 
14781 
  def write(self, oprot):
14782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14784 
      return
14785 
    oprot.writeStructBegin('getAllCampaigns_args')
14786 
    oprot.writeFieldStop()
14787 
    oprot.writeStructEnd()
14788 
 
14789 
  def validate(self):
14790 
    return
14791 
 
14792 
 
14793 
  def __repr__(self):
14794 
    L = ['%s=%r' % (key, value)
14795 
      for key, value in self.__dict__.iteritems()]
14796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14797 
 
14798 
  def __eq__(self, other):
14799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14800 
 
14801 
  def __ne__(self, other):
14802 
    return not (self == other)
14803 
 
14804 
class getAllCampaigns_result:
14805 
  """
14806 
  Attributes:
14807 
   - success
14808 
  """
14809 
 
14810 
  thrift_spec = (
14811 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14812 
  )
14813 
 
14814 
  def __init__(self, success=None,):
14815 
    self.success = success
14816 
 
14817 
  def read(self, iprot):
14818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14820 
      return
14821 
    iprot.readStructBegin()
14822 
    while True:
14823 
      (fname, ftype, fid) = iprot.readFieldBegin()
14824 
      if ftype == TType.STOP:
14825 
        break
14826 
      if fid == 0:
14827 
        if ftype == TType.LIST:
14828 
          self.success = []
8590 kshitij.so 14829 
          (_etype256, _size253) = iprot.readListBegin()
14830 
          for _i257 in xrange(_size253):
14831 
            _elem258 = iprot.readString();
14832 
            self.success.append(_elem258)
8579 kshitij.so 14833 
          iprot.readListEnd()
14834 
        else:
14835 
          iprot.skip(ftype)
14836 
      else:
14837 
        iprot.skip(ftype)
14838 
      iprot.readFieldEnd()
14839 
    iprot.readStructEnd()
14840 
 
14841 
  def write(self, oprot):
14842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14844 
      return
14845 
    oprot.writeStructBegin('getAllCampaigns_result')
14846 
    if self.success is not None:
14847 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14848 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14849 
      for iter259 in self.success:
14850 
        oprot.writeString(iter259)
8579 kshitij.so 14851 
      oprot.writeListEnd()
14852 
      oprot.writeFieldEnd()
14853 
    oprot.writeFieldStop()
14854 
    oprot.writeStructEnd()
14855 
 
14856 
  def validate(self):
14857 
    return
14858 
 
14859 
 
14860 
  def __repr__(self):
14861 
    L = ['%s=%r' % (key, value)
14862 
      for key, value in self.__dict__.iteritems()]
14863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14864 
 
14865 
  def __eq__(self, other):
14866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14867 
 
14868 
  def __ne__(self, other):
14869 
    return not (self == other)
14870 
 
9155 kshitij.so 14871 
class getActiveBannersForMobileSite_args:
14872 
 
14873 
  thrift_spec = (
14874 
  )
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 
      else:
14886 
        iprot.skip(ftype)
14887 
      iprot.readFieldEnd()
14888 
    iprot.readStructEnd()
14889 
 
14890 
  def write(self, oprot):
14891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14893 
      return
14894 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
14895 
    oprot.writeFieldStop()
14896 
    oprot.writeStructEnd()
14897 
 
14898 
  def validate(self):
14899 
    return
14900 
 
14901 
 
14902 
  def __repr__(self):
14903 
    L = ['%s=%r' % (key, value)
14904 
      for key, value in self.__dict__.iteritems()]
14905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14906 
 
14907 
  def __eq__(self, other):
14908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14909 
 
14910 
  def __ne__(self, other):
14911 
    return not (self == other)
14912 
 
14913 
class getActiveBannersForMobileSite_result:
14914 
  """
14915 
  Attributes:
14916 
   - success
14917 
  """
14918 
 
14919 
  thrift_spec = (
14920 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
14921 
  )
14922 
 
14923 
  def __init__(self, success=None,):
14924 
    self.success = success
14925 
 
14926 
  def read(self, iprot):
14927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14929 
      return
14930 
    iprot.readStructBegin()
14931 
    while True:
14932 
      (fname, ftype, fid) = iprot.readFieldBegin()
14933 
      if ftype == TType.STOP:
14934 
        break
14935 
      if fid == 0:
14936 
        if ftype == TType.MAP:
14937 
          self.success = {}
14938 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
14939 
          for _i264 in xrange(_size260):
14940 
            _key265 = iprot.readString();
14941 
            _val266 = []
14942 
            (_etype270, _size267) = iprot.readListBegin()
14943 
            for _i271 in xrange(_size267):
14944 
              _elem272 = Banner()
14945 
              _elem272.read(iprot)
14946 
              _val266.append(_elem272)
14947 
            iprot.readListEnd()
14948 
            self.success[_key265] = _val266
14949 
          iprot.readMapEnd()
14950 
        else:
14951 
          iprot.skip(ftype)
14952 
      else:
14953 
        iprot.skip(ftype)
14954 
      iprot.readFieldEnd()
14955 
    iprot.readStructEnd()
14956 
 
14957 
  def write(self, oprot):
14958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14960 
      return
14961 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
14962 
    if self.success is not None:
14963 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14964 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
14965 
      for kiter273,viter274 in self.success.items():
14966 
        oprot.writeString(kiter273)
14967 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
14968 
        for iter275 in viter274:
14969 
          iter275.write(oprot)
14970 
        oprot.writeListEnd()
14971 
      oprot.writeMapEnd()
14972 
      oprot.writeFieldEnd()
14973 
    oprot.writeFieldStop()
14974 
    oprot.writeStructEnd()
14975 
 
14976 
  def validate(self):
14977 
    return
14978 
 
14979 
 
14980 
  def __repr__(self):
14981 
    L = ['%s=%r' % (key, value)
14982 
      for key, value in self.__dict__.iteritems()]
14983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14984 
 
14985 
  def __eq__(self, other):
14986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14987 
 
14988 
  def __ne__(self, other):
14989 
    return not (self == other)
14990 
 
5944 mandeep.dh 14991 
class deleteSimilarItem_args:
14992 
  """
14993 
  Attributes:
14994 
   - itemId
14995 
   - catalogItemId
14996 
  """
14997 
 
14998 
  thrift_spec = (
14999 
    None, # 0
15000 
    (1, TType.I64, 'itemId', None, None, ), # 1
15001 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
15002 
  )
15003 
 
15004 
  def __init__(self, itemId=None, catalogItemId=None,):
15005 
    self.itemId = itemId
15006 
    self.catalogItemId = catalogItemId
15007 
 
15008 
  def read(self, iprot):
15009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15011 
      return
15012 
    iprot.readStructBegin()
15013 
    while True:
15014 
      (fname, ftype, fid) = iprot.readFieldBegin()
15015 
      if ftype == TType.STOP:
15016 
        break
15017 
      if fid == 1:
15018 
        if ftype == TType.I64:
15019 
          self.itemId = iprot.readI64();
15020 
        else:
15021 
          iprot.skip(ftype)
15022 
      elif fid == 2:
15023 
        if ftype == TType.I64:
15024 
          self.catalogItemId = iprot.readI64();
15025 
        else:
15026 
          iprot.skip(ftype)
15027 
      else:
15028 
        iprot.skip(ftype)
15029 
      iprot.readFieldEnd()
15030 
    iprot.readStructEnd()
15031 
 
15032 
  def write(self, oprot):
15033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15035 
      return
15036 
    oprot.writeStructBegin('deleteSimilarItem_args')
15037 
    if self.itemId is not None:
15038 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15039 
      oprot.writeI64(self.itemId)
15040 
      oprot.writeFieldEnd()
15041 
    if self.catalogItemId is not None:
15042 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
15043 
      oprot.writeI64(self.catalogItemId)
15044 
      oprot.writeFieldEnd()
15045 
    oprot.writeFieldStop()
15046 
    oprot.writeStructEnd()
15047 
 
15048 
  def validate(self):
15049 
    return
15050 
 
15051 
 
15052 
  def __repr__(self):
15053 
    L = ['%s=%r' % (key, value)
15054 
      for key, value in self.__dict__.iteritems()]
15055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15056 
 
15057 
  def __eq__(self, other):
15058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15059 
 
15060 
  def __ne__(self, other):
15061 
    return not (self == other)
15062 
 
15063 
class deleteSimilarItem_result:
15064 
  """
15065 
  Attributes:
15066 
   - success
15067 
   - cex
15068 
  """
15069 
 
15070 
  thrift_spec = (
15071 
    (0, TType.BOOL, 'success', None, None, ), # 0
15072 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15073 
  )
15074 
 
15075 
  def __init__(self, success=None, cex=None,):
15076 
    self.success = success
15077 
    self.cex = cex
15078 
 
15079 
  def read(self, iprot):
15080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15082 
      return
15083 
    iprot.readStructBegin()
15084 
    while True:
15085 
      (fname, ftype, fid) = iprot.readFieldBegin()
15086 
      if ftype == TType.STOP:
15087 
        break
15088 
      if fid == 0:
15089 
        if ftype == TType.BOOL:
15090 
          self.success = iprot.readBool();
15091 
        else:
15092 
          iprot.skip(ftype)
15093 
      elif fid == 1:
15094 
        if ftype == TType.STRUCT:
15095 
          self.cex = CatalogServiceException()
15096 
          self.cex.read(iprot)
15097 
        else:
15098 
          iprot.skip(ftype)
15099 
      else:
15100 
        iprot.skip(ftype)
15101 
      iprot.readFieldEnd()
15102 
    iprot.readStructEnd()
15103 
 
15104 
  def write(self, oprot):
15105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15107 
      return
15108 
    oprot.writeStructBegin('deleteSimilarItem_result')
15109 
    if self.success is not None:
15110 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15111 
      oprot.writeBool(self.success)
15112 
      oprot.writeFieldEnd()
15113 
    if self.cex is not None:
15114 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15115 
      self.cex.write(oprot)
15116 
      oprot.writeFieldEnd()
15117 
    oprot.writeFieldStop()
15118 
    oprot.writeStructEnd()
15119 
 
15120 
  def validate(self):
15121 
    return
15122 
 
15123 
 
15124 
  def __repr__(self):
15125 
    L = ['%s=%r' % (key, value)
15126 
      for key, value in self.__dict__.iteritems()]
15127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15128 
 
15129 
  def __eq__(self, other):
15130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15131 
 
15132 
  def __ne__(self, other):
15133 
    return not (self == other)
15134 
 
15135 
class checkSimilarItem_args:
15136 
  """
15137 
  Attributes:
15138 
   - brand
15139 
   - modelNumber
15140 
   - modelName
15141 
   - color
15142 
  """
15143 
 
15144 
  thrift_spec = (
15145 
    None, # 0
15146 
    (1, TType.STRING, 'brand', None, None, ), # 1
15147 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
15148 
    (3, TType.STRING, 'modelName', None, None, ), # 3
15149 
    (4, TType.STRING, 'color', None, None, ), # 4
15150 
  )
15151 
 
15152 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
15153 
    self.brand = brand
15154 
    self.modelNumber = modelNumber
15155 
    self.modelName = modelName
15156 
    self.color = color
15157 
 
15158 
  def read(self, iprot):
15159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15161 
      return
15162 
    iprot.readStructBegin()
15163 
    while True:
15164 
      (fname, ftype, fid) = iprot.readFieldBegin()
15165 
      if ftype == TType.STOP:
15166 
        break
15167 
      if fid == 1:
15168 
        if ftype == TType.STRING:
15169 
          self.brand = iprot.readString();
15170 
        else:
15171 
          iprot.skip(ftype)
15172 
      elif fid == 2:
15173 
        if ftype == TType.STRING:
15174 
          self.modelNumber = iprot.readString();
15175 
        else:
15176 
          iprot.skip(ftype)
15177 
      elif fid == 3:
15178 
        if ftype == TType.STRING:
15179 
          self.modelName = iprot.readString();
15180 
        else:
15181 
          iprot.skip(ftype)
15182 
      elif fid == 4:
15183 
        if ftype == TType.STRING:
15184 
          self.color = iprot.readString();
15185 
        else:
15186 
          iprot.skip(ftype)
15187 
      else:
15188 
        iprot.skip(ftype)
15189 
      iprot.readFieldEnd()
15190 
    iprot.readStructEnd()
15191 
 
15192 
  def write(self, oprot):
15193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15195 
      return
15196 
    oprot.writeStructBegin('checkSimilarItem_args')
15197 
    if self.brand is not None:
15198 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
15199 
      oprot.writeString(self.brand)
15200 
      oprot.writeFieldEnd()
15201 
    if self.modelNumber is not None:
15202 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
15203 
      oprot.writeString(self.modelNumber)
15204 
      oprot.writeFieldEnd()
15205 
    if self.modelName is not None:
15206 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
15207 
      oprot.writeString(self.modelName)
15208 
      oprot.writeFieldEnd()
15209 
    if self.color is not None:
15210 
      oprot.writeFieldBegin('color', TType.STRING, 4)
15211 
      oprot.writeString(self.color)
15212 
      oprot.writeFieldEnd()
15213 
    oprot.writeFieldStop()
15214 
    oprot.writeStructEnd()
15215 
 
15216 
  def validate(self):
15217 
    return
15218 
 
15219 
 
15220 
  def __repr__(self):
15221 
    L = ['%s=%r' % (key, value)
15222 
      for key, value in self.__dict__.iteritems()]
15223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15224 
 
15225 
  def __eq__(self, other):
15226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15227 
 
15228 
  def __ne__(self, other):
15229 
    return not (self == other)
15230 
 
15231 
class checkSimilarItem_result:
15232 
  """
15233 
  Attributes:
15234 
   - success
15235 
  """
15236 
 
15237 
  thrift_spec = (
15238 
    (0, TType.I64, 'success', None, None, ), # 0
15239 
  )
15240 
 
15241 
  def __init__(self, success=None,):
15242 
    self.success = success
15243 
 
15244 
  def read(self, iprot):
15245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15247 
      return
15248 
    iprot.readStructBegin()
15249 
    while True:
15250 
      (fname, ftype, fid) = iprot.readFieldBegin()
15251 
      if ftype == TType.STOP:
15252 
        break
15253 
      if fid == 0:
15254 
        if ftype == TType.I64:
15255 
          self.success = iprot.readI64();
15256 
        else:
15257 
          iprot.skip(ftype)
15258 
      else:
15259 
        iprot.skip(ftype)
15260 
      iprot.readFieldEnd()
15261 
    iprot.readStructEnd()
15262 
 
15263 
  def write(self, oprot):
15264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15266 
      return
15267 
    oprot.writeStructBegin('checkSimilarItem_result')
15268 
    if self.success is not None:
15269 
      oprot.writeFieldBegin('success', TType.I64, 0)
15270 
      oprot.writeI64(self.success)
15271 
      oprot.writeFieldEnd()
15272 
    oprot.writeFieldStop()
15273 
    oprot.writeStructEnd()
15274 
 
15275 
  def validate(self):
15276 
    return
15277 
 
15278 
 
15279 
  def __repr__(self):
15280 
    L = ['%s=%r' % (key, value)
15281 
      for key, value in self.__dict__.iteritems()]
15282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15283 
 
15284 
  def __eq__(self, other):
15285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15286 
 
15287 
  def __ne__(self, other):
15288 
    return not (self == other)
15289 
 
15290 
class validateRiskyStatus_args:
15291 
  """
15292 
  Attributes:
15293 
   - itemId
15294 
  """
15295 
 
15296 
  thrift_spec = (
15297 
    None, # 0
15298 
    (1, TType.I64, 'itemId', None, None, ), # 1
15299 
  )
15300 
 
15301 
  def __init__(self, itemId=None,):
15302 
    self.itemId = itemId
15303 
 
15304 
  def read(self, iprot):
15305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15307 
      return
15308 
    iprot.readStructBegin()
15309 
    while True:
15310 
      (fname, ftype, fid) = iprot.readFieldBegin()
15311 
      if ftype == TType.STOP:
15312 
        break
15313 
      if fid == 1:
15314 
        if ftype == TType.I64:
15315 
          self.itemId = iprot.readI64();
15316 
        else:
15317 
          iprot.skip(ftype)
15318 
      else:
15319 
        iprot.skip(ftype)
15320 
      iprot.readFieldEnd()
15321 
    iprot.readStructEnd()
15322 
 
15323 
  def write(self, oprot):
15324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15326 
      return
15327 
    oprot.writeStructBegin('validateRiskyStatus_args')
15328 
    if self.itemId is not None:
15329 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15330 
      oprot.writeI64(self.itemId)
15331 
      oprot.writeFieldEnd()
15332 
    oprot.writeFieldStop()
15333 
    oprot.writeStructEnd()
15334 
 
15335 
  def validate(self):
15336 
    return
15337 
 
15338 
 
15339 
  def __repr__(self):
15340 
    L = ['%s=%r' % (key, value)
15341 
      for key, value in self.__dict__.iteritems()]
15342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15343 
 
15344 
  def __eq__(self, other):
15345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15346 
 
15347 
  def __ne__(self, other):
15348 
    return not (self == other)
15349 
 
15350 
class validateRiskyStatus_result:
15351 
 
15352 
  thrift_spec = (
15353 
  )
15354 
 
15355 
  def read(self, iprot):
15356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15358 
      return
15359 
    iprot.readStructBegin()
15360 
    while True:
15361 
      (fname, ftype, fid) = iprot.readFieldBegin()
15362 
      if ftype == TType.STOP:
15363 
        break
15364 
      else:
15365 
        iprot.skip(ftype)
15366 
      iprot.readFieldEnd()
15367 
    iprot.readStructEnd()
15368 
 
15369 
  def write(self, oprot):
15370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15372 
      return
15373 
    oprot.writeStructBegin('validateRiskyStatus_result')
15374 
    oprot.writeFieldStop()
15375 
    oprot.writeStructEnd()
15376 
 
15377 
  def validate(self):
15378 
    return
15379 
 
15380 
 
15381 
  def __repr__(self):
15382 
    L = ['%s=%r' % (key, value)
15383 
      for key, value in self.__dict__.iteritems()]
15384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15385 
 
15386 
  def __eq__(self, other):
15387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15388 
 
15389 
  def __ne__(self, other):
15390 
    return not (self == other)
15391 
 
15392 
class changeItemRiskyFlag_args:
15393 
  """
15394 
  Attributes:
15395 
   - itemId
15396 
   - risky
15397 
  """
15398 
 
15399 
  thrift_spec = (
15400 
    None, # 0
15401 
    (1, TType.I64, 'itemId', None, None, ), # 1
15402 
    (2, TType.BOOL, 'risky', None, None, ), # 2
15403 
  )
15404 
 
15405 
  def __init__(self, itemId=None, risky=None,):
15406 
    self.itemId = itemId
15407 
    self.risky = risky
15408 
 
15409 
  def read(self, iprot):
15410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15412 
      return
15413 
    iprot.readStructBegin()
15414 
    while True:
15415 
      (fname, ftype, fid) = iprot.readFieldBegin()
15416 
      if ftype == TType.STOP:
15417 
        break
15418 
      if fid == 1:
15419 
        if ftype == TType.I64:
15420 
          self.itemId = iprot.readI64();
15421 
        else:
15422 
          iprot.skip(ftype)
15423 
      elif fid == 2:
15424 
        if ftype == TType.BOOL:
15425 
          self.risky = iprot.readBool();
15426 
        else:
15427 
          iprot.skip(ftype)
15428 
      else:
15429 
        iprot.skip(ftype)
15430 
      iprot.readFieldEnd()
15431 
    iprot.readStructEnd()
15432 
 
15433 
  def write(self, oprot):
15434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15436 
      return
15437 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
15438 
    if self.itemId is not None:
15439 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15440 
      oprot.writeI64(self.itemId)
15441 
      oprot.writeFieldEnd()
15442 
    if self.risky is not None:
15443 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
15444 
      oprot.writeBool(self.risky)
15445 
      oprot.writeFieldEnd()
15446 
    oprot.writeFieldStop()
15447 
    oprot.writeStructEnd()
15448 
 
15449 
  def validate(self):
15450 
    return
15451 
 
15452 
 
15453 
  def __repr__(self):
15454 
    L = ['%s=%r' % (key, value)
15455 
      for key, value in self.__dict__.iteritems()]
15456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15457 
 
15458 
  def __eq__(self, other):
15459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15460 
 
15461 
  def __ne__(self, other):
15462 
    return not (self == other)
15463 
 
15464 
class changeItemRiskyFlag_result:
15465 
 
15466 
  thrift_spec = (
15467 
  )
15468 
 
15469 
  def read(self, iprot):
15470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15472 
      return
15473 
    iprot.readStructBegin()
15474 
    while True:
15475 
      (fname, ftype, fid) = iprot.readFieldBegin()
15476 
      if ftype == TType.STOP:
15477 
        break
15478 
      else:
15479 
        iprot.skip(ftype)
15480 
      iprot.readFieldEnd()
15481 
    iprot.readStructEnd()
15482 
 
15483 
  def write(self, oprot):
15484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15486 
      return
15487 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
15488 
    oprot.writeFieldStop()
15489 
    oprot.writeStructEnd()
15490 
 
15491 
  def validate(self):
15492 
    return
15493 
 
15494 
 
15495 
  def __repr__(self):
15496 
    L = ['%s=%r' % (key, value)
15497 
      for key, value in self.__dict__.iteritems()]
15498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15499 
 
15500 
  def __eq__(self, other):
15501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15502 
 
15503 
  def __ne__(self, other):
15504 
    return not (self == other)
15505 
 
15506 
class getItemsByRiskyFlag_args:
15507 
 
15508 
  thrift_spec = (
15509 
  )
15510 
 
15511 
  def read(self, iprot):
15512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15514 
      return
15515 
    iprot.readStructBegin()
15516 
    while True:
15517 
      (fname, ftype, fid) = iprot.readFieldBegin()
15518 
      if ftype == TType.STOP:
15519 
        break
15520 
      else:
15521 
        iprot.skip(ftype)
15522 
      iprot.readFieldEnd()
15523 
    iprot.readStructEnd()
15524 
 
15525 
  def write(self, oprot):
15526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15528 
      return
15529 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
15530 
    oprot.writeFieldStop()
15531 
    oprot.writeStructEnd()
15532 
 
15533 
  def validate(self):
15534 
    return
15535 
 
15536 
 
15537 
  def __repr__(self):
15538 
    L = ['%s=%r' % (key, value)
15539 
      for key, value in self.__dict__.iteritems()]
15540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15541 
 
15542 
  def __eq__(self, other):
15543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15544 
 
15545 
  def __ne__(self, other):
15546 
    return not (self == other)
15547 
 
15548 
class getItemsByRiskyFlag_result:
15549 
  """
15550 
  Attributes:
15551 
   - success
15552 
  """
15553 
 
15554 
  thrift_spec = (
15555 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15556 
  )
15557 
 
15558 
  def __init__(self, success=None,):
15559 
    self.success = success
15560 
 
15561 
  def read(self, iprot):
15562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15564 
      return
15565 
    iprot.readStructBegin()
15566 
    while True:
15567 
      (fname, ftype, fid) = iprot.readFieldBegin()
15568 
      if ftype == TType.STOP:
15569 
        break
15570 
      if fid == 0:
15571 
        if ftype == TType.LIST:
15572 
          self.success = []
9155 kshitij.so 15573 
          (_etype279, _size276) = iprot.readListBegin()
15574 
          for _i280 in xrange(_size276):
15575 
            _elem281 = Item()
15576 
            _elem281.read(iprot)
15577 
            self.success.append(_elem281)
5944 mandeep.dh 15578 
          iprot.readListEnd()
15579 
        else:
15580 
          iprot.skip(ftype)
15581 
      else:
15582 
        iprot.skip(ftype)
15583 
      iprot.readFieldEnd()
15584 
    iprot.readStructEnd()
15585 
 
15586 
  def write(self, oprot):
15587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15589 
      return
15590 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
15591 
    if self.success is not None:
15592 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15593 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15594 
      for iter282 in self.success:
15595 
        iter282.write(oprot)
5944 mandeep.dh 15596 
      oprot.writeListEnd()
15597 
      oprot.writeFieldEnd()
15598 
    oprot.writeFieldStop()
15599 
    oprot.writeStructEnd()
15600 
 
15601 
  def validate(self):
15602 
    return
15603 
 
15604 
 
15605 
  def __repr__(self):
15606 
    L = ['%s=%r' % (key, value)
15607 
      for key, value in self.__dict__.iteritems()]
15608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15609 
 
15610 
  def __eq__(self, other):
15611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15612 
 
15613 
  def __ne__(self, other):
15614 
    return not (self == other)
15615 
 
15616 
class getItemsForMasterSheet_args:
15617 
  """
15618 
  Attributes:
15619 
   - category
15620 
   - brand
15621 
  """
15622 
 
15623 
  thrift_spec = (
15624 
    None, # 0
15625 
    (1, TType.STRING, 'category', None, None, ), # 1
15626 
    (2, TType.STRING, 'brand', None, None, ), # 2
15627 
  )
15628 
 
15629 
  def __init__(self, category=None, brand=None,):
15630 
    self.category = category
15631 
    self.brand = brand
15632 
 
15633 
  def read(self, iprot):
15634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15636 
      return
15637 
    iprot.readStructBegin()
15638 
    while True:
15639 
      (fname, ftype, fid) = iprot.readFieldBegin()
15640 
      if ftype == TType.STOP:
15641 
        break
15642 
      if fid == 1:
15643 
        if ftype == TType.STRING:
15644 
          self.category = iprot.readString();
15645 
        else:
15646 
          iprot.skip(ftype)
15647 
      elif fid == 2:
15648 
        if ftype == TType.STRING:
15649 
          self.brand = iprot.readString();
15650 
        else:
15651 
          iprot.skip(ftype)
15652 
      else:
15653 
        iprot.skip(ftype)
15654 
      iprot.readFieldEnd()
15655 
    iprot.readStructEnd()
15656 
 
15657 
  def write(self, oprot):
15658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15660 
      return
15661 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
15662 
    if self.category is not None:
15663 
      oprot.writeFieldBegin('category', TType.STRING, 1)
15664 
      oprot.writeString(self.category)
15665 
      oprot.writeFieldEnd()
15666 
    if self.brand is not None:
15667 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
15668 
      oprot.writeString(self.brand)
15669 
      oprot.writeFieldEnd()
15670 
    oprot.writeFieldStop()
15671 
    oprot.writeStructEnd()
15672 
 
15673 
  def validate(self):
15674 
    return
15675 
 
15676 
 
15677 
  def __repr__(self):
15678 
    L = ['%s=%r' % (key, value)
15679 
      for key, value in self.__dict__.iteritems()]
15680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15681 
 
15682 
  def __eq__(self, other):
15683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15684 
 
15685 
  def __ne__(self, other):
15686 
    return not (self == other)
15687 
 
15688 
class getItemsForMasterSheet_result:
15689 
  """
15690 
  Attributes:
15691 
   - success
15692 
  """
15693 
 
15694 
  thrift_spec = (
15695 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15696 
  )
15697 
 
15698 
  def __init__(self, success=None,):
15699 
    self.success = success
15700 
 
15701 
  def read(self, iprot):
15702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15704 
      return
15705 
    iprot.readStructBegin()
15706 
    while True:
15707 
      (fname, ftype, fid) = iprot.readFieldBegin()
15708 
      if ftype == TType.STOP:
15709 
        break
15710 
      if fid == 0:
15711 
        if ftype == TType.LIST:
15712 
          self.success = []
9155 kshitij.so 15713 
          (_etype286, _size283) = iprot.readListBegin()
15714 
          for _i287 in xrange(_size283):
15715 
            _elem288 = Item()
15716 
            _elem288.read(iprot)
15717 
            self.success.append(_elem288)
5944 mandeep.dh 15718 
          iprot.readListEnd()
15719 
        else:
15720 
          iprot.skip(ftype)
15721 
      else:
15722 
        iprot.skip(ftype)
15723 
      iprot.readFieldEnd()
15724 
    iprot.readStructEnd()
15725 
 
15726 
  def write(self, oprot):
15727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15729 
      return
15730 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
15731 
    if self.success is not None:
15732 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15733 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15734 
      for iter289 in self.success:
15735 
        iter289.write(oprot)
5944 mandeep.dh 15736 
      oprot.writeListEnd()
15737 
      oprot.writeFieldEnd()
15738 
    oprot.writeFieldStop()
15739 
    oprot.writeStructEnd()
15740 
 
15741 
  def validate(self):
15742 
    return
15743 
 
15744 
 
15745 
  def __repr__(self):
15746 
    L = ['%s=%r' % (key, value)
15747 
      for key, value in self.__dict__.iteritems()]
15748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15749 
 
15750 
  def __eq__(self, other):
15751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15752 
 
15753 
  def __ne__(self, other):
15754 
    return not (self == other)
15755 
 
15756 
class getSimilarItemsCatalogIds_args:
15757 
  """
15758 
  Attributes:
15759 
   - beginIndex
15760 
   - totalItems
15761 
   - itemId
15762 
  """
15763 
 
15764 
  thrift_spec = (
15765 
    None, # 0
15766 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
15767 
    (2, TType.I64, 'totalItems', None, None, ), # 2
15768 
    (3, TType.I64, 'itemId', None, None, ), # 3
15769 
  )
15770 
 
15771 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
15772 
    self.beginIndex = beginIndex
15773 
    self.totalItems = totalItems
15774 
    self.itemId = itemId
15775 
 
15776 
  def read(self, iprot):
15777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15779 
      return
15780 
    iprot.readStructBegin()
15781 
    while True:
15782 
      (fname, ftype, fid) = iprot.readFieldBegin()
15783 
      if ftype == TType.STOP:
15784 
        break
15785 
      if fid == 1:
15786 
        if ftype == TType.I64:
15787 
          self.beginIndex = iprot.readI64();
15788 
        else:
15789 
          iprot.skip(ftype)
15790 
      elif fid == 2:
15791 
        if ftype == TType.I64:
15792 
          self.totalItems = iprot.readI64();
15793 
        else:
15794 
          iprot.skip(ftype)
15795 
      elif fid == 3:
15796 
        if ftype == TType.I64:
15797 
          self.itemId = iprot.readI64();
15798 
        else:
15799 
          iprot.skip(ftype)
15800 
      else:
15801 
        iprot.skip(ftype)
15802 
      iprot.readFieldEnd()
15803 
    iprot.readStructEnd()
15804 
 
15805 
  def write(self, oprot):
15806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15808 
      return
15809 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
15810 
    if self.beginIndex is not None:
15811 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
15812 
      oprot.writeI64(self.beginIndex)
15813 
      oprot.writeFieldEnd()
15814 
    if self.totalItems is not None:
15815 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
15816 
      oprot.writeI64(self.totalItems)
15817 
      oprot.writeFieldEnd()
15818 
    if self.itemId is not None:
15819 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
15820 
      oprot.writeI64(self.itemId)
15821 
      oprot.writeFieldEnd()
15822 
    oprot.writeFieldStop()
15823 
    oprot.writeStructEnd()
15824 
 
15825 
  def validate(self):
15826 
    return
15827 
 
15828 
 
15829 
  def __repr__(self):
15830 
    L = ['%s=%r' % (key, value)
15831 
      for key, value in self.__dict__.iteritems()]
15832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15833 
 
15834 
  def __eq__(self, other):
15835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15836 
 
15837 
  def __ne__(self, other):
15838 
    return not (self == other)
15839 
 
15840 
class getSimilarItemsCatalogIds_result:
15841 
  """
15842 
  Attributes:
15843 
   - success
15844 
  """
15845 
 
15846 
  thrift_spec = (
15847 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15848 
  )
15849 
 
15850 
  def __init__(self, success=None,):
15851 
    self.success = success
15852 
 
15853 
  def read(self, iprot):
15854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15856 
      return
15857 
    iprot.readStructBegin()
15858 
    while True:
15859 
      (fname, ftype, fid) = iprot.readFieldBegin()
15860 
      if ftype == TType.STOP:
15861 
        break
15862 
      if fid == 0:
15863 
        if ftype == TType.LIST:
15864 
          self.success = []
9155 kshitij.so 15865 
          (_etype293, _size290) = iprot.readListBegin()
15866 
          for _i294 in xrange(_size290):
15867 
            _elem295 = iprot.readI64();
15868 
            self.success.append(_elem295)
5944 mandeep.dh 15869 
          iprot.readListEnd()
15870 
        else:
15871 
          iprot.skip(ftype)
15872 
      else:
15873 
        iprot.skip(ftype)
15874 
      iprot.readFieldEnd()
15875 
    iprot.readStructEnd()
15876 
 
15877 
  def write(self, oprot):
15878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15880 
      return
15881 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
15882 
    if self.success is not None:
15883 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15884 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 15885 
      for iter296 in self.success:
15886 
        oprot.writeI64(iter296)
5944 mandeep.dh 15887 
      oprot.writeListEnd()
15888 
      oprot.writeFieldEnd()
15889 
    oprot.writeFieldStop()
15890 
    oprot.writeStructEnd()
15891 
 
15892 
  def validate(self):
15893 
    return
15894 
 
15895 
 
15896 
  def __repr__(self):
15897 
    L = ['%s=%r' % (key, value)
15898 
      for key, value in self.__dict__.iteritems()]
15899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15900 
 
15901 
  def __eq__(self, other):
15902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15903 
 
15904 
  def __ne__(self, other):
15905 
    return not (self == other)
15906 
 
15907 
class addProductNotification_args:
15908 
  """
15909 
  Attributes:
15910 
   - itemId
15911 
   - email
15912 
  """
15913 
 
15914 
  thrift_spec = None
15915 
  def __init__(self, itemId=None, email=None,):
15916 
    self.itemId = itemId
15917 
    self.email = email
15918 
 
15919 
  def read(self, iprot):
15920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15922 
      return
15923 
    iprot.readStructBegin()
15924 
    while True:
15925 
      (fname, ftype, fid) = iprot.readFieldBegin()
15926 
      if ftype == TType.STOP:
15927 
        break
15928 
      if fid == -1:
15929 
        if ftype == TType.I64:
15930 
          self.itemId = iprot.readI64();
15931 
        else:
15932 
          iprot.skip(ftype)
15933 
      elif fid == -2:
15934 
        if ftype == TType.STRING:
15935 
          self.email = iprot.readString();
15936 
        else:
15937 
          iprot.skip(ftype)
15938 
      else:
15939 
        iprot.skip(ftype)
15940 
      iprot.readFieldEnd()
15941 
    iprot.readStructEnd()
15942 
 
15943 
  def write(self, oprot):
15944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15946 
      return
15947 
    oprot.writeStructBegin('addProductNotification_args')
15948 
    if self.email is not None:
15949 
      oprot.writeFieldBegin('email', TType.STRING, -2)
15950 
      oprot.writeString(self.email)
15951 
      oprot.writeFieldEnd()
15952 
    if self.itemId is not None:
15953 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
15954 
      oprot.writeI64(self.itemId)
15955 
      oprot.writeFieldEnd()
15956 
    oprot.writeFieldStop()
15957 
    oprot.writeStructEnd()
15958 
 
15959 
  def validate(self):
15960 
    return
15961 
 
15962 
 
15963 
  def __repr__(self):
15964 
    L = ['%s=%r' % (key, value)
15965 
      for key, value in self.__dict__.iteritems()]
15966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15967 
 
15968 
  def __eq__(self, other):
15969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15970 
 
15971 
  def __ne__(self, other):
15972 
    return not (self == other)
15973 
 
15974 
class addProductNotification_result:
15975 
  """
15976 
  Attributes:
15977 
   - success
15978 
  """
15979 
 
15980 
  thrift_spec = (
15981 
    (0, TType.BOOL, 'success', None, None, ), # 0
15982 
  )
15983 
 
15984 
  def __init__(self, success=None,):
15985 
    self.success = success
15986 
 
15987 
  def read(self, iprot):
15988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15990 
      return
15991 
    iprot.readStructBegin()
15992 
    while True:
15993 
      (fname, ftype, fid) = iprot.readFieldBegin()
15994 
      if ftype == TType.STOP:
15995 
        break
15996 
      if fid == 0:
15997 
        if ftype == TType.BOOL:
15998 
          self.success = iprot.readBool();
15999 
        else:
16000 
          iprot.skip(ftype)
16001 
      else:
16002 
        iprot.skip(ftype)
16003 
      iprot.readFieldEnd()
16004 
    iprot.readStructEnd()
16005 
 
16006 
  def write(self, oprot):
16007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16009 
      return
16010 
    oprot.writeStructBegin('addProductNotification_result')
16011 
    if self.success is not None:
16012 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16013 
      oprot.writeBool(self.success)
16014 
      oprot.writeFieldEnd()
16015 
    oprot.writeFieldStop()
16016 
    oprot.writeStructEnd()
16017 
 
16018 
  def validate(self):
16019 
    return
16020 
 
16021 
 
16022 
  def __repr__(self):
16023 
    L = ['%s=%r' % (key, value)
16024 
      for key, value in self.__dict__.iteritems()]
16025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16026 
 
16027 
  def __eq__(self, other):
16028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16029 
 
16030 
  def __ne__(self, other):
16031 
    return not (self == other)
16032 
 
16033 
class sendProductNotifications_args:
16034 
 
16035 
  thrift_spec = (
16036 
  )
16037 
 
16038 
  def read(self, iprot):
16039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16041 
      return
16042 
    iprot.readStructBegin()
16043 
    while True:
16044 
      (fname, ftype, fid) = iprot.readFieldBegin()
16045 
      if ftype == TType.STOP:
16046 
        break
16047 
      else:
16048 
        iprot.skip(ftype)
16049 
      iprot.readFieldEnd()
16050 
    iprot.readStructEnd()
16051 
 
16052 
  def write(self, oprot):
16053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16055 
      return
16056 
    oprot.writeStructBegin('sendProductNotifications_args')
16057 
    oprot.writeFieldStop()
16058 
    oprot.writeStructEnd()
16059 
 
16060 
  def validate(self):
16061 
    return
16062 
 
16063 
 
16064 
  def __repr__(self):
16065 
    L = ['%s=%r' % (key, value)
16066 
      for key, value in self.__dict__.iteritems()]
16067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16068 
 
16069 
  def __eq__(self, other):
16070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16071 
 
16072 
  def __ne__(self, other):
16073 
    return not (self == other)
16074 
 
16075 
class sendProductNotifications_result:
16076 
  """
16077 
  Attributes:
16078 
   - success
16079 
  """
16080 
 
16081 
  thrift_spec = (
16082 
    (0, TType.BOOL, 'success', None, None, ), # 0
16083 
  )
16084 
 
16085 
  def __init__(self, success=None,):
16086 
    self.success = success
16087 
 
16088 
  def read(self, iprot):
16089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16091 
      return
16092 
    iprot.readStructBegin()
16093 
    while True:
16094 
      (fname, ftype, fid) = iprot.readFieldBegin()
16095 
      if ftype == TType.STOP:
16096 
        break
16097 
      if fid == 0:
16098 
        if ftype == TType.BOOL:
16099 
          self.success = iprot.readBool();
16100 
        else:
16101 
          iprot.skip(ftype)
16102 
      else:
16103 
        iprot.skip(ftype)
16104 
      iprot.readFieldEnd()
16105 
    iprot.readStructEnd()
16106 
 
16107 
  def write(self, oprot):
16108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16110 
      return
16111 
    oprot.writeStructBegin('sendProductNotifications_result')
16112 
    if self.success is not None:
16113 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16114 
      oprot.writeBool(self.success)
16115 
      oprot.writeFieldEnd()
16116 
    oprot.writeFieldStop()
16117 
    oprot.writeStructEnd()
16118 
 
16119 
  def validate(self):
16120 
    return
16121 
 
16122 
 
16123 
  def __repr__(self):
16124 
    L = ['%s=%r' % (key, value)
16125 
      for key, value in self.__dict__.iteritems()]
16126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16127 
 
16128 
  def __eq__(self, other):
16129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16130 
 
16131 
  def __ne__(self, other):
16132 
    return not (self == other)
16133 
 
16134 
class getAllBrandsByCategory_args:
16135 
  """
16136 
  Attributes:
16137 
   - categoryId
16138 
  """
16139 
 
16140 
  thrift_spec = (
16141 
    None, # 0
16142 
    (1, TType.I64, 'categoryId', None, None, ), # 1
16143 
  )
16144 
 
16145 
  def __init__(self, categoryId=None,):
16146 
    self.categoryId = categoryId
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.categoryId = iprot.readI64();
16160 
        else:
16161 
          iprot.skip(ftype)
16162 
      else:
16163 
        iprot.skip(ftype)
16164 
      iprot.readFieldEnd()
16165 
    iprot.readStructEnd()
16166 
 
16167 
  def write(self, oprot):
16168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16170 
      return
16171 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
16172 
    if self.categoryId is not None:
16173 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
16174 
      oprot.writeI64(self.categoryId)
16175 
      oprot.writeFieldEnd()
16176 
    oprot.writeFieldStop()
16177 
    oprot.writeStructEnd()
16178 
 
16179 
  def validate(self):
16180 
    return
16181 
 
16182 
 
16183 
  def __repr__(self):
16184 
    L = ['%s=%r' % (key, value)
16185 
      for key, value in self.__dict__.iteritems()]
16186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16187 
 
16188 
  def __eq__(self, other):
16189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16190 
 
16191 
  def __ne__(self, other):
16192 
    return not (self == other)
16193 
 
16194 
class getAllBrandsByCategory_result:
16195 
  """
16196 
  Attributes:
16197 
   - success
16198 
  """
16199 
 
16200 
  thrift_spec = (
16201 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16202 
  )
16203 
 
16204 
  def __init__(self, success=None,):
16205 
    self.success = success
16206 
 
16207 
  def read(self, iprot):
16208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16210 
      return
16211 
    iprot.readStructBegin()
16212 
    while True:
16213 
      (fname, ftype, fid) = iprot.readFieldBegin()
16214 
      if ftype == TType.STOP:
16215 
        break
16216 
      if fid == 0:
16217 
        if ftype == TType.LIST:
16218 
          self.success = []
9155 kshitij.so 16219 
          (_etype300, _size297) = iprot.readListBegin()
16220 
          for _i301 in xrange(_size297):
16221 
            _elem302 = iprot.readString();
16222 
            self.success.append(_elem302)
5944 mandeep.dh 16223 
          iprot.readListEnd()
16224 
        else:
16225 
          iprot.skip(ftype)
16226 
      else:
16227 
        iprot.skip(ftype)
16228 
      iprot.readFieldEnd()
16229 
    iprot.readStructEnd()
16230 
 
16231 
  def write(self, oprot):
16232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16234 
      return
16235 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
16236 
    if self.success is not None:
16237 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16238 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16239 
      for iter303 in self.success:
16240 
        oprot.writeString(iter303)
5944 mandeep.dh 16241 
      oprot.writeListEnd()
16242 
      oprot.writeFieldEnd()
16243 
    oprot.writeFieldStop()
16244 
    oprot.writeStructEnd()
16245 
 
16246 
  def validate(self):
16247 
    return
16248 
 
16249 
 
16250 
  def __repr__(self):
16251 
    L = ['%s=%r' % (key, value)
16252 
      for key, value in self.__dict__.iteritems()]
16253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16254 
 
16255 
  def __eq__(self, other):
16256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16257 
 
16258 
  def __ne__(self, other):
16259 
    return not (self == other)
16260 
 
16261 
class getAllBrands_args:
16262 
 
16263 
  thrift_spec = (
16264 
  )
16265 
 
16266 
  def read(self, iprot):
16267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16269 
      return
16270 
    iprot.readStructBegin()
16271 
    while True:
16272 
      (fname, ftype, fid) = iprot.readFieldBegin()
16273 
      if ftype == TType.STOP:
16274 
        break
16275 
      else:
16276 
        iprot.skip(ftype)
16277 
      iprot.readFieldEnd()
16278 
    iprot.readStructEnd()
16279 
 
16280 
  def write(self, oprot):
16281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16283 
      return
16284 
    oprot.writeStructBegin('getAllBrands_args')
16285 
    oprot.writeFieldStop()
16286 
    oprot.writeStructEnd()
16287 
 
16288 
  def validate(self):
16289 
    return
16290 
 
16291 
 
16292 
  def __repr__(self):
16293 
    L = ['%s=%r' % (key, value)
16294 
      for key, value in self.__dict__.iteritems()]
16295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16296 
 
16297 
  def __eq__(self, other):
16298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16299 
 
16300 
  def __ne__(self, other):
16301 
    return not (self == other)
16302 
 
16303 
class getAllBrands_result:
16304 
  """
16305 
  Attributes:
16306 
   - success
16307 
  """
16308 
 
16309 
  thrift_spec = (
16310 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16311 
  )
16312 
 
16313 
  def __init__(self, success=None,):
16314 
    self.success = success
16315 
 
16316 
  def read(self, iprot):
16317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16319 
      return
16320 
    iprot.readStructBegin()
16321 
    while True:
16322 
      (fname, ftype, fid) = iprot.readFieldBegin()
16323 
      if ftype == TType.STOP:
16324 
        break
16325 
      if fid == 0:
16326 
        if ftype == TType.LIST:
16327 
          self.success = []
9155 kshitij.so 16328 
          (_etype307, _size304) = iprot.readListBegin()
16329 
          for _i308 in xrange(_size304):
16330 
            _elem309 = iprot.readString();
16331 
            self.success.append(_elem309)
5944 mandeep.dh 16332 
          iprot.readListEnd()
16333 
        else:
16334 
          iprot.skip(ftype)
16335 
      else:
16336 
        iprot.skip(ftype)
16337 
      iprot.readFieldEnd()
16338 
    iprot.readStructEnd()
16339 
 
16340 
  def write(self, oprot):
16341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16343 
      return
16344 
    oprot.writeStructBegin('getAllBrands_result')
16345 
    if self.success is not None:
16346 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16347 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16348 
      for iter310 in self.success:
16349 
        oprot.writeString(iter310)
5944 mandeep.dh 16350 
      oprot.writeListEnd()
16351 
      oprot.writeFieldEnd()
16352 
    oprot.writeFieldStop()
16353 
    oprot.writeStructEnd()
16354 
 
16355 
  def validate(self):
16356 
    return
16357 
 
16358 
 
16359 
  def __repr__(self):
16360 
    L = ['%s=%r' % (key, value)
16361 
      for key, value in self.__dict__.iteritems()]
16362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16363 
 
16364 
  def __eq__(self, other):
16365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16366 
 
16367 
  def __ne__(self, other):
16368 
    return not (self == other)
16369 
 
16370 
class getAllSources_args:
16371 
 
16372 
  thrift_spec = (
16373 
  )
16374 
 
16375 
  def read(self, iprot):
16376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16378 
      return
16379 
    iprot.readStructBegin()
16380 
    while True:
16381 
      (fname, ftype, fid) = iprot.readFieldBegin()
16382 
      if ftype == TType.STOP:
16383 
        break
16384 
      else:
16385 
        iprot.skip(ftype)
16386 
      iprot.readFieldEnd()
16387 
    iprot.readStructEnd()
16388 
 
16389 
  def write(self, oprot):
16390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16392 
      return
16393 
    oprot.writeStructBegin('getAllSources_args')
16394 
    oprot.writeFieldStop()
16395 
    oprot.writeStructEnd()
16396 
 
16397 
  def validate(self):
16398 
    return
16399 
 
16400 
 
16401 
  def __repr__(self):
16402 
    L = ['%s=%r' % (key, value)
16403 
      for key, value in self.__dict__.iteritems()]
16404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16405 
 
16406 
  def __eq__(self, other):
16407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16408 
 
16409 
  def __ne__(self, other):
16410 
    return not (self == other)
16411 
 
16412 
class getAllSources_result:
16413 
  """
16414 
  Attributes:
16415 
   - success
16416 
  """
16417 
 
16418 
  thrift_spec = (
16419 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
16420 
  )
16421 
 
16422 
  def __init__(self, success=None,):
16423 
    self.success = success
16424 
 
16425 
  def read(self, iprot):
16426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16428 
      return
16429 
    iprot.readStructBegin()
16430 
    while True:
16431 
      (fname, ftype, fid) = iprot.readFieldBegin()
16432 
      if ftype == TType.STOP:
16433 
        break
16434 
      if fid == 0:
16435 
        if ftype == TType.LIST:
16436 
          self.success = []
9155 kshitij.so 16437 
          (_etype314, _size311) = iprot.readListBegin()
16438 
          for _i315 in xrange(_size311):
16439 
            _elem316 = Source()
16440 
            _elem316.read(iprot)
16441 
            self.success.append(_elem316)
5944 mandeep.dh 16442 
          iprot.readListEnd()
16443 
        else:
16444 
          iprot.skip(ftype)
16445 
      else:
16446 
        iprot.skip(ftype)
16447 
      iprot.readFieldEnd()
16448 
    iprot.readStructEnd()
16449 
 
16450 
  def write(self, oprot):
16451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16453 
      return
16454 
    oprot.writeStructBegin('getAllSources_result')
16455 
    if self.success is not None:
16456 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16457 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16458 
      for iter317 in self.success:
16459 
        iter317.write(oprot)
5944 mandeep.dh 16460 
      oprot.writeListEnd()
16461 
      oprot.writeFieldEnd()
16462 
    oprot.writeFieldStop()
16463 
    oprot.writeStructEnd()
16464 
 
16465 
  def validate(self):
16466 
    return
16467 
 
16468 
 
16469 
  def __repr__(self):
16470 
    L = ['%s=%r' % (key, value)
16471 
      for key, value in self.__dict__.iteritems()]
16472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16473 
 
16474 
  def __eq__(self, other):
16475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16476 
 
16477 
  def __ne__(self, other):
16478 
    return not (self == other)
16479 
 
16480 
class getItemPricingBySource_args:
16481 
  """
16482 
  Attributes:
16483 
   - itemId
16484 
   - sourceId
16485 
  """
16486 
 
16487 
  thrift_spec = (
16488 
    None, # 0
16489 
    (1, TType.I64, 'itemId', None, None, ), # 1
16490 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16491 
  )
16492 
 
16493 
  def __init__(self, itemId=None, sourceId=None,):
16494 
    self.itemId = itemId
16495 
    self.sourceId = sourceId
16496 
 
16497 
  def read(self, iprot):
16498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16500 
      return
16501 
    iprot.readStructBegin()
16502 
    while True:
16503 
      (fname, ftype, fid) = iprot.readFieldBegin()
16504 
      if ftype == TType.STOP:
16505 
        break
16506 
      if fid == 1:
16507 
        if ftype == TType.I64:
16508 
          self.itemId = iprot.readI64();
16509 
        else:
16510 
          iprot.skip(ftype)
16511 
      elif fid == 2:
16512 
        if ftype == TType.I64:
16513 
          self.sourceId = iprot.readI64();
16514 
        else:
16515 
          iprot.skip(ftype)
16516 
      else:
16517 
        iprot.skip(ftype)
16518 
      iprot.readFieldEnd()
16519 
    iprot.readStructEnd()
16520 
 
16521 
  def write(self, oprot):
16522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16524 
      return
16525 
    oprot.writeStructBegin('getItemPricingBySource_args')
16526 
    if self.itemId is not None:
16527 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16528 
      oprot.writeI64(self.itemId)
16529 
      oprot.writeFieldEnd()
16530 
    if self.sourceId is not None:
16531 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16532 
      oprot.writeI64(self.sourceId)
16533 
      oprot.writeFieldEnd()
16534 
    oprot.writeFieldStop()
16535 
    oprot.writeStructEnd()
16536 
 
16537 
  def validate(self):
16538 
    return
16539 
 
16540 
 
16541 
  def __repr__(self):
16542 
    L = ['%s=%r' % (key, value)
16543 
      for key, value in self.__dict__.iteritems()]
16544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16545 
 
16546 
  def __eq__(self, other):
16547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16548 
 
16549 
  def __ne__(self, other):
16550 
    return not (self == other)
16551 
 
16552 
class getItemPricingBySource_result:
16553 
  """
16554 
  Attributes:
16555 
   - success
16556 
   - cex
16557 
  """
16558 
 
16559 
  thrift_spec = (
16560 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
16561 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16562 
  )
16563 
 
16564 
  def __init__(self, success=None, cex=None,):
16565 
    self.success = success
16566 
    self.cex = cex
16567 
 
16568 
  def read(self, iprot):
16569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16571 
      return
16572 
    iprot.readStructBegin()
16573 
    while True:
16574 
      (fname, ftype, fid) = iprot.readFieldBegin()
16575 
      if ftype == TType.STOP:
16576 
        break
16577 
      if fid == 0:
16578 
        if ftype == TType.STRUCT:
16579 
          self.success = SourceItemPricing()
16580 
          self.success.read(iprot)
16581 
        else:
16582 
          iprot.skip(ftype)
16583 
      elif fid == 1:
16584 
        if ftype == TType.STRUCT:
16585 
          self.cex = CatalogServiceException()
16586 
          self.cex.read(iprot)
16587 
        else:
16588 
          iprot.skip(ftype)
16589 
      else:
16590 
        iprot.skip(ftype)
16591 
      iprot.readFieldEnd()
16592 
    iprot.readStructEnd()
16593 
 
16594 
  def write(self, oprot):
16595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16597 
      return
16598 
    oprot.writeStructBegin('getItemPricingBySource_result')
16599 
    if self.success is not None:
16600 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16601 
      self.success.write(oprot)
16602 
      oprot.writeFieldEnd()
16603 
    if self.cex is not None:
16604 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16605 
      self.cex.write(oprot)
16606 
      oprot.writeFieldEnd()
16607 
    oprot.writeFieldStop()
16608 
    oprot.writeStructEnd()
16609 
 
16610 
  def validate(self):
16611 
    return
16612 
 
16613 
 
16614 
  def __repr__(self):
16615 
    L = ['%s=%r' % (key, value)
16616 
      for key, value in self.__dict__.iteritems()]
16617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16618 
 
16619 
  def __eq__(self, other):
16620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16621 
 
16622 
  def __ne__(self, other):
16623 
    return not (self == other)
16624 
 
16625 
class addSourceItemPricing_args:
16626 
  """
16627 
  Attributes:
16628 
   - sourceItemPricing
16629 
  """
16630 
 
16631 
  thrift_spec = (
16632 
    None, # 0
16633 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
16634 
  )
16635 
 
16636 
  def __init__(self, sourceItemPricing=None,):
16637 
    self.sourceItemPricing = sourceItemPricing
16638 
 
16639 
  def read(self, iprot):
16640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16642 
      return
16643 
    iprot.readStructBegin()
16644 
    while True:
16645 
      (fname, ftype, fid) = iprot.readFieldBegin()
16646 
      if ftype == TType.STOP:
16647 
        break
16648 
      if fid == 1:
16649 
        if ftype == TType.STRUCT:
16650 
          self.sourceItemPricing = SourceItemPricing()
16651 
          self.sourceItemPricing.read(iprot)
16652 
        else:
16653 
          iprot.skip(ftype)
16654 
      else:
16655 
        iprot.skip(ftype)
16656 
      iprot.readFieldEnd()
16657 
    iprot.readStructEnd()
16658 
 
16659 
  def write(self, oprot):
16660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16662 
      return
16663 
    oprot.writeStructBegin('addSourceItemPricing_args')
16664 
    if self.sourceItemPricing is not None:
16665 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
16666 
      self.sourceItemPricing.write(oprot)
16667 
      oprot.writeFieldEnd()
16668 
    oprot.writeFieldStop()
16669 
    oprot.writeStructEnd()
16670 
 
16671 
  def validate(self):
16672 
    return
16673 
 
16674 
 
16675 
  def __repr__(self):
16676 
    L = ['%s=%r' % (key, value)
16677 
      for key, value in self.__dict__.iteritems()]
16678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16679 
 
16680 
  def __eq__(self, other):
16681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16682 
 
16683 
  def __ne__(self, other):
16684 
    return not (self == other)
16685 
 
16686 
class addSourceItemPricing_result:
16687 
  """
16688 
  Attributes:
16689 
   - cex
16690 
  """
16691 
 
16692 
  thrift_spec = (
16693 
    None, # 0
16694 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16695 
  )
16696 
 
16697 
  def __init__(self, cex=None,):
16698 
    self.cex = cex
16699 
 
16700 
  def read(self, iprot):
16701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16703 
      return
16704 
    iprot.readStructBegin()
16705 
    while True:
16706 
      (fname, ftype, fid) = iprot.readFieldBegin()
16707 
      if ftype == TType.STOP:
16708 
        break
16709 
      if fid == 1:
16710 
        if ftype == TType.STRUCT:
16711 
          self.cex = CatalogServiceException()
16712 
          self.cex.read(iprot)
16713 
        else:
16714 
          iprot.skip(ftype)
16715 
      else:
16716 
        iprot.skip(ftype)
16717 
      iprot.readFieldEnd()
16718 
    iprot.readStructEnd()
16719 
 
16720 
  def write(self, oprot):
16721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16723 
      return
16724 
    oprot.writeStructBegin('addSourceItemPricing_result')
16725 
    if self.cex is not None:
16726 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16727 
      self.cex.write(oprot)
16728 
      oprot.writeFieldEnd()
16729 
    oprot.writeFieldStop()
16730 
    oprot.writeStructEnd()
16731 
 
16732 
  def validate(self):
16733 
    return
16734 
 
16735 
 
16736 
  def __repr__(self):
16737 
    L = ['%s=%r' % (key, value)
16738 
      for key, value in self.__dict__.iteritems()]
16739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16740 
 
16741 
  def __eq__(self, other):
16742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16743 
 
16744 
  def __ne__(self, other):
16745 
    return not (self == other)
16746 
 
16747 
class getAllSourcePricing_args:
16748 
  """
16749 
  Attributes:
16750 
   - itemId
16751 
  """
16752 
 
16753 
  thrift_spec = (
16754 
    None, # 0
16755 
    (1, TType.I64, 'itemId', None, None, ), # 1
16756 
  )
16757 
 
16758 
  def __init__(self, itemId=None,):
16759 
    self.itemId = itemId
16760 
 
16761 
  def read(self, iprot):
16762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16764 
      return
16765 
    iprot.readStructBegin()
16766 
    while True:
16767 
      (fname, ftype, fid) = iprot.readFieldBegin()
16768 
      if ftype == TType.STOP:
16769 
        break
16770 
      if fid == 1:
16771 
        if ftype == TType.I64:
16772 
          self.itemId = iprot.readI64();
16773 
        else:
16774 
          iprot.skip(ftype)
16775 
      else:
16776 
        iprot.skip(ftype)
16777 
      iprot.readFieldEnd()
16778 
    iprot.readStructEnd()
16779 
 
16780 
  def write(self, oprot):
16781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16783 
      return
16784 
    oprot.writeStructBegin('getAllSourcePricing_args')
16785 
    if self.itemId is not None:
16786 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16787 
      oprot.writeI64(self.itemId)
16788 
      oprot.writeFieldEnd()
16789 
    oprot.writeFieldStop()
16790 
    oprot.writeStructEnd()
16791 
 
16792 
  def validate(self):
16793 
    return
16794 
 
16795 
 
16796 
  def __repr__(self):
16797 
    L = ['%s=%r' % (key, value)
16798 
      for key, value in self.__dict__.iteritems()]
16799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16800 
 
16801 
  def __eq__(self, other):
16802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16803 
 
16804 
  def __ne__(self, other):
16805 
    return not (self == other)
16806 
 
16807 
class getAllSourcePricing_result:
16808 
  """
16809 
  Attributes:
16810 
   - success
16811 
   - cex
16812 
  """
16813 
 
16814 
  thrift_spec = (
16815 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
16816 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16817 
  )
16818 
 
16819 
  def __init__(self, success=None, cex=None,):
16820 
    self.success = success
16821 
    self.cex = cex
16822 
 
16823 
  def read(self, iprot):
16824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16826 
      return
16827 
    iprot.readStructBegin()
16828 
    while True:
16829 
      (fname, ftype, fid) = iprot.readFieldBegin()
16830 
      if ftype == TType.STOP:
16831 
        break
16832 
      if fid == 0:
16833 
        if ftype == TType.LIST:
16834 
          self.success = []
9155 kshitij.so 16835 
          (_etype321, _size318) = iprot.readListBegin()
16836 
          for _i322 in xrange(_size318):
16837 
            _elem323 = SourceItemPricing()
16838 
            _elem323.read(iprot)
16839 
            self.success.append(_elem323)
5944 mandeep.dh 16840 
          iprot.readListEnd()
16841 
        else:
16842 
          iprot.skip(ftype)
16843 
      elif fid == 1:
16844 
        if ftype == TType.STRUCT:
16845 
          self.cex = CatalogServiceException()
16846 
          self.cex.read(iprot)
16847 
        else:
16848 
          iprot.skip(ftype)
16849 
      else:
16850 
        iprot.skip(ftype)
16851 
      iprot.readFieldEnd()
16852 
    iprot.readStructEnd()
16853 
 
16854 
  def write(self, oprot):
16855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16857 
      return
16858 
    oprot.writeStructBegin('getAllSourcePricing_result')
16859 
    if self.success is not None:
16860 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16861 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16862 
      for iter324 in self.success:
16863 
        iter324.write(oprot)
5944 mandeep.dh 16864 
      oprot.writeListEnd()
16865 
      oprot.writeFieldEnd()
16866 
    if self.cex is not None:
16867 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16868 
      self.cex.write(oprot)
16869 
      oprot.writeFieldEnd()
16870 
    oprot.writeFieldStop()
16871 
    oprot.writeStructEnd()
16872 
 
16873 
  def validate(self):
16874 
    return
16875 
 
16876 
 
16877 
  def __repr__(self):
16878 
    L = ['%s=%r' % (key, value)
16879 
      for key, value in self.__dict__.iteritems()]
16880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16881 
 
16882 
  def __eq__(self, other):
16883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16884 
 
16885 
  def __ne__(self, other):
16886 
    return not (self == other)
16887 
 
16888 
class getItemForSource_args:
16889 
  """
16890 
  Attributes:
16891 
   - item_id
16892 
   - sourceId
16893 
  """
16894 
 
16895 
  thrift_spec = (
16896 
    None, # 0
16897 
    (1, TType.I64, 'item_id', None, None, ), # 1
16898 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16899 
  )
16900 
 
16901 
  def __init__(self, item_id=None, sourceId=None,):
16902 
    self.item_id = item_id
16903 
    self.sourceId = sourceId
16904 
 
16905 
  def read(self, iprot):
16906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16908 
      return
16909 
    iprot.readStructBegin()
16910 
    while True:
16911 
      (fname, ftype, fid) = iprot.readFieldBegin()
16912 
      if ftype == TType.STOP:
16913 
        break
16914 
      if fid == 1:
16915 
        if ftype == TType.I64:
16916 
          self.item_id = iprot.readI64();
16917 
        else:
16918 
          iprot.skip(ftype)
16919 
      elif fid == 2:
16920 
        if ftype == TType.I64:
16921 
          self.sourceId = iprot.readI64();
16922 
        else:
16923 
          iprot.skip(ftype)
16924 
      else:
16925 
        iprot.skip(ftype)
16926 
      iprot.readFieldEnd()
16927 
    iprot.readStructEnd()
16928 
 
16929 
  def write(self, oprot):
16930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16932 
      return
16933 
    oprot.writeStructBegin('getItemForSource_args')
16934 
    if self.item_id is not None:
16935 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
16936 
      oprot.writeI64(self.item_id)
16937 
      oprot.writeFieldEnd()
16938 
    if self.sourceId is not None:
16939 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16940 
      oprot.writeI64(self.sourceId)
16941 
      oprot.writeFieldEnd()
16942 
    oprot.writeFieldStop()
16943 
    oprot.writeStructEnd()
16944 
 
16945 
  def validate(self):
16946 
    return
16947 
 
16948 
 
16949 
  def __repr__(self):
16950 
    L = ['%s=%r' % (key, value)
16951 
      for key, value in self.__dict__.iteritems()]
16952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16953 
 
16954 
  def __eq__(self, other):
16955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16956 
 
16957 
  def __ne__(self, other):
16958 
    return not (self == other)
16959 
 
16960 
class getItemForSource_result:
16961 
  """
16962 
  Attributes:
16963 
   - success
16964 
   - cex
16965 
  """
16966 
 
16967 
  thrift_spec = (
16968 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
16969 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16970 
  )
16971 
 
16972 
  def __init__(self, success=None, cex=None,):
16973 
    self.success = success
16974 
    self.cex = cex
16975 
 
16976 
  def read(self, iprot):
16977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16979 
      return
16980 
    iprot.readStructBegin()
16981 
    while True:
16982 
      (fname, ftype, fid) = iprot.readFieldBegin()
16983 
      if ftype == TType.STOP:
16984 
        break
16985 
      if fid == 0:
16986 
        if ftype == TType.STRUCT:
16987 
          self.success = Item()
16988 
          self.success.read(iprot)
16989 
        else:
16990 
          iprot.skip(ftype)
16991 
      elif fid == 1:
16992 
        if ftype == TType.STRUCT:
16993 
          self.cex = CatalogServiceException()
16994 
          self.cex.read(iprot)
16995 
        else:
16996 
          iprot.skip(ftype)
16997 
      else:
16998 
        iprot.skip(ftype)
16999 
      iprot.readFieldEnd()
17000 
    iprot.readStructEnd()
17001 
 
17002 
  def write(self, oprot):
17003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17005 
      return
17006 
    oprot.writeStructBegin('getItemForSource_result')
17007 
    if self.success is not None:
17008 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17009 
      self.success.write(oprot)
17010 
      oprot.writeFieldEnd()
17011 
    if self.cex is not None:
17012 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17013 
      self.cex.write(oprot)
17014 
      oprot.writeFieldEnd()
17015 
    oprot.writeFieldStop()
17016 
    oprot.writeStructEnd()
17017 
 
17018 
  def validate(self):
17019 
    return
17020 
 
17021 
 
17022 
  def __repr__(self):
17023 
    L = ['%s=%r' % (key, value)
17024 
      for key, value in self.__dict__.iteritems()]
17025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17026 
 
17027 
  def __eq__(self, other):
17028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17029 
 
17030 
  def __ne__(self, other):
17031 
    return not (self == other)
17032 
 
17033 
class searchItemsInRange_args:
17034 
  """
17035 
  Attributes:
17036 
   - searchTerms
17037 
   - offset
17038 
   - limit
17039 
  """
17040 
 
17041 
  thrift_spec = (
17042 
    None, # 0
17043 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17044 
    (2, TType.I64, 'offset', None, None, ), # 2
17045 
    (3, TType.I64, 'limit', None, None, ), # 3
17046 
  )
17047 
 
17048 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
17049 
    self.searchTerms = searchTerms
17050 
    self.offset = offset
17051 
    self.limit = limit
17052 
 
17053 
  def read(self, iprot):
17054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17056 
      return
17057 
    iprot.readStructBegin()
17058 
    while True:
17059 
      (fname, ftype, fid) = iprot.readFieldBegin()
17060 
      if ftype == TType.STOP:
17061 
        break
17062 
      if fid == 1:
17063 
        if ftype == TType.LIST:
17064 
          self.searchTerms = []
9155 kshitij.so 17065 
          (_etype328, _size325) = iprot.readListBegin()
17066 
          for _i329 in xrange(_size325):
17067 
            _elem330 = iprot.readString();
17068 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 17069 
          iprot.readListEnd()
17070 
        else:
17071 
          iprot.skip(ftype)
17072 
      elif fid == 2:
17073 
        if ftype == TType.I64:
17074 
          self.offset = iprot.readI64();
17075 
        else:
17076 
          iprot.skip(ftype)
17077 
      elif fid == 3:
17078 
        if ftype == TType.I64:
17079 
          self.limit = iprot.readI64();
17080 
        else:
17081 
          iprot.skip(ftype)
17082 
      else:
17083 
        iprot.skip(ftype)
17084 
      iprot.readFieldEnd()
17085 
    iprot.readStructEnd()
17086 
 
17087 
  def write(self, oprot):
17088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17090 
      return
17091 
    oprot.writeStructBegin('searchItemsInRange_args')
17092 
    if self.searchTerms is not None:
17093 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17094 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17095 
      for iter331 in self.searchTerms:
17096 
        oprot.writeString(iter331)
5944 mandeep.dh 17097 
      oprot.writeListEnd()
17098 
      oprot.writeFieldEnd()
17099 
    if self.offset is not None:
17100 
      oprot.writeFieldBegin('offset', TType.I64, 2)
17101 
      oprot.writeI64(self.offset)
17102 
      oprot.writeFieldEnd()
17103 
    if self.limit is not None:
17104 
      oprot.writeFieldBegin('limit', TType.I64, 3)
17105 
      oprot.writeI64(self.limit)
17106 
      oprot.writeFieldEnd()
17107 
    oprot.writeFieldStop()
17108 
    oprot.writeStructEnd()
17109 
 
17110 
  def validate(self):
17111 
    return
17112 
 
17113 
 
17114 
  def __repr__(self):
17115 
    L = ['%s=%r' % (key, value)
17116 
      for key, value in self.__dict__.iteritems()]
17117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17118 
 
17119 
  def __eq__(self, other):
17120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17121 
 
17122 
  def __ne__(self, other):
17123 
    return not (self == other)
17124 
 
17125 
class searchItemsInRange_result:
17126 
  """
17127 
  Attributes:
17128 
   - success
17129 
  """
17130 
 
17131 
  thrift_spec = (
17132 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17133 
  )
17134 
 
17135 
  def __init__(self, success=None,):
17136 
    self.success = success
17137 
 
17138 
  def read(self, iprot):
17139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17141 
      return
17142 
    iprot.readStructBegin()
17143 
    while True:
17144 
      (fname, ftype, fid) = iprot.readFieldBegin()
17145 
      if ftype == TType.STOP:
17146 
        break
17147 
      if fid == 0:
17148 
        if ftype == TType.LIST:
17149 
          self.success = []
9155 kshitij.so 17150 
          (_etype335, _size332) = iprot.readListBegin()
17151 
          for _i336 in xrange(_size332):
17152 
            _elem337 = Item()
17153 
            _elem337.read(iprot)
17154 
            self.success.append(_elem337)
5944 mandeep.dh 17155 
          iprot.readListEnd()
17156 
        else:
17157 
          iprot.skip(ftype)
17158 
      else:
17159 
        iprot.skip(ftype)
17160 
      iprot.readFieldEnd()
17161 
    iprot.readStructEnd()
17162 
 
17163 
  def write(self, oprot):
17164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17166 
      return
17167 
    oprot.writeStructBegin('searchItemsInRange_result')
17168 
    if self.success is not None:
17169 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17170 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17171 
      for iter338 in self.success:
17172 
        iter338.write(oprot)
5944 mandeep.dh 17173 
      oprot.writeListEnd()
17174 
      oprot.writeFieldEnd()
17175 
    oprot.writeFieldStop()
17176 
    oprot.writeStructEnd()
17177 
 
17178 
  def validate(self):
17179 
    return
17180 
 
17181 
 
17182 
  def __repr__(self):
17183 
    L = ['%s=%r' % (key, value)
17184 
      for key, value in self.__dict__.iteritems()]
17185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17186 
 
17187 
  def __eq__(self, other):
17188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17189 
 
17190 
  def __ne__(self, other):
17191 
    return not (self == other)
17192 
 
17193 
class getSearchResultCount_args:
17194 
  """
17195 
  Attributes:
17196 
   - searchTerms
17197 
  """
17198 
 
17199 
  thrift_spec = (
17200 
    None, # 0
17201 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17202 
  )
17203 
 
17204 
  def __init__(self, searchTerms=None,):
17205 
    self.searchTerms = searchTerms
17206 
 
17207 
  def read(self, iprot):
17208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17210 
      return
17211 
    iprot.readStructBegin()
17212 
    while True:
17213 
      (fname, ftype, fid) = iprot.readFieldBegin()
17214 
      if ftype == TType.STOP:
17215 
        break
17216 
      if fid == 1:
17217 
        if ftype == TType.LIST:
17218 
          self.searchTerms = []
9155 kshitij.so 17219 
          (_etype342, _size339) = iprot.readListBegin()
17220 
          for _i343 in xrange(_size339):
17221 
            _elem344 = iprot.readString();
17222 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 17223 
          iprot.readListEnd()
17224 
        else:
17225 
          iprot.skip(ftype)
17226 
      else:
17227 
        iprot.skip(ftype)
17228 
      iprot.readFieldEnd()
17229 
    iprot.readStructEnd()
17230 
 
17231 
  def write(self, oprot):
17232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17234 
      return
17235 
    oprot.writeStructBegin('getSearchResultCount_args')
17236 
    if self.searchTerms is not None:
17237 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17238 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17239 
      for iter345 in self.searchTerms:
17240 
        oprot.writeString(iter345)
5944 mandeep.dh 17241 
      oprot.writeListEnd()
17242 
      oprot.writeFieldEnd()
17243 
    oprot.writeFieldStop()
17244 
    oprot.writeStructEnd()
17245 
 
17246 
  def validate(self):
17247 
    return
17248 
 
17249 
 
17250 
  def __repr__(self):
17251 
    L = ['%s=%r' % (key, value)
17252 
      for key, value in self.__dict__.iteritems()]
17253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17254 
 
17255 
  def __eq__(self, other):
17256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17257 
 
17258 
  def __ne__(self, other):
17259 
    return not (self == other)
17260 
 
17261 
class getSearchResultCount_result:
17262 
  """
17263 
  Attributes:
17264 
   - success
17265 
  """
17266 
 
17267 
  thrift_spec = (
17268 
    (0, TType.I32, 'success', None, None, ), # 0
17269 
  )
17270 
 
17271 
  def __init__(self, success=None,):
17272 
    self.success = success
17273 
 
17274 
  def read(self, iprot):
17275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17277 
      return
17278 
    iprot.readStructBegin()
17279 
    while True:
17280 
      (fname, ftype, fid) = iprot.readFieldBegin()
17281 
      if ftype == TType.STOP:
17282 
        break
17283 
      if fid == 0:
17284 
        if ftype == TType.I32:
17285 
          self.success = iprot.readI32();
17286 
        else:
17287 
          iprot.skip(ftype)
17288 
      else:
17289 
        iprot.skip(ftype)
17290 
      iprot.readFieldEnd()
17291 
    iprot.readStructEnd()
17292 
 
17293 
  def write(self, oprot):
17294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17296 
      return
17297 
    oprot.writeStructBegin('getSearchResultCount_result')
17298 
    if self.success is not None:
17299 
      oprot.writeFieldBegin('success', TType.I32, 0)
17300 
      oprot.writeI32(self.success)
17301 
      oprot.writeFieldEnd()
17302 
    oprot.writeFieldStop()
17303 
    oprot.writeStructEnd()
17304 
 
17305 
  def validate(self):
17306 
    return
17307 
 
17308 
 
17309 
  def __repr__(self):
17310 
    L = ['%s=%r' % (key, value)
17311 
      for key, value in self.__dict__.iteritems()]
17312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17313 
 
17314 
  def __eq__(self, other):
17315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17316 
 
17317 
  def __ne__(self, other):
17318 
    return not (self == other)
17319 
 
17320 
class getProductNotifications_args:
17321 
  """
17322 
  Attributes:
17323 
   - startDateTime
17324 
  """
17325 
 
17326 
  thrift_spec = (
17327 
    None, # 0
17328 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
17329 
  )
17330 
 
17331 
  def __init__(self, startDateTime=None,):
17332 
    self.startDateTime = startDateTime
17333 
 
17334 
  def read(self, iprot):
17335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17337 
      return
17338 
    iprot.readStructBegin()
17339 
    while True:
17340 
      (fname, ftype, fid) = iprot.readFieldBegin()
17341 
      if ftype == TType.STOP:
17342 
        break
17343 
      if fid == 1:
17344 
        if ftype == TType.I64:
17345 
          self.startDateTime = iprot.readI64();
17346 
        else:
17347 
          iprot.skip(ftype)
17348 
      else:
17349 
        iprot.skip(ftype)
17350 
      iprot.readFieldEnd()
17351 
    iprot.readStructEnd()
17352 
 
17353 
  def write(self, oprot):
17354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17356 
      return
17357 
    oprot.writeStructBegin('getProductNotifications_args')
17358 
    if self.startDateTime is not None:
17359 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17360 
      oprot.writeI64(self.startDateTime)
17361 
      oprot.writeFieldEnd()
17362 
    oprot.writeFieldStop()
17363 
    oprot.writeStructEnd()
17364 
 
17365 
  def validate(self):
17366 
    return
17367 
 
17368 
 
17369 
  def __repr__(self):
17370 
    L = ['%s=%r' % (key, value)
17371 
      for key, value in self.__dict__.iteritems()]
17372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17373 
 
17374 
  def __eq__(self, other):
17375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17376 
 
17377 
  def __ne__(self, other):
17378 
    return not (self == other)
17379 
 
17380 
class getProductNotifications_result:
17381 
  """
17382 
  Attributes:
17383 
   - success
17384 
  """
17385 
 
17386 
  thrift_spec = (
17387 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
17388 
  )
17389 
 
17390 
  def __init__(self, success=None,):
17391 
    self.success = success
17392 
 
17393 
  def read(self, iprot):
17394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17396 
      return
17397 
    iprot.readStructBegin()
17398 
    while True:
17399 
      (fname, ftype, fid) = iprot.readFieldBegin()
17400 
      if ftype == TType.STOP:
17401 
        break
17402 
      if fid == 0:
17403 
        if ftype == TType.LIST:
17404 
          self.success = []
9155 kshitij.so 17405 
          (_etype349, _size346) = iprot.readListBegin()
17406 
          for _i350 in xrange(_size346):
17407 
            _elem351 = ProductNotificationRequest()
17408 
            _elem351.read(iprot)
17409 
            self.success.append(_elem351)
5944 mandeep.dh 17410 
          iprot.readListEnd()
17411 
        else:
17412 
          iprot.skip(ftype)
17413 
      else:
17414 
        iprot.skip(ftype)
17415 
      iprot.readFieldEnd()
17416 
    iprot.readStructEnd()
17417 
 
17418 
  def write(self, oprot):
17419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17421 
      return
17422 
    oprot.writeStructBegin('getProductNotifications_result')
17423 
    if self.success is not None:
17424 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17425 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17426 
      for iter352 in self.success:
17427 
        iter352.write(oprot)
5944 mandeep.dh 17428 
      oprot.writeListEnd()
17429 
      oprot.writeFieldEnd()
17430 
    oprot.writeFieldStop()
17431 
    oprot.writeStructEnd()
17432 
 
17433 
  def validate(self):
17434 
    return
17435 
 
17436 
 
17437 
  def __repr__(self):
17438 
    L = ['%s=%r' % (key, value)
17439 
      for key, value in self.__dict__.iteritems()]
17440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17441 
 
17442 
  def __eq__(self, other):
17443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17444 
 
17445 
  def __ne__(self, other):
17446 
    return not (self == other)
17447 
 
17448 
class getProductNotificationRequestCount_args:
17449 
  """
17450 
  Attributes:
17451 
   - startDateTime
7897 amar.kumar 17452 
   - categoryId
5944 mandeep.dh 17453 
  """
17454 
 
17455 
  thrift_spec = (
17456 
    None, # 0
17457 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 17458 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 17459 
  )
17460 
 
7897 amar.kumar 17461 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 17462 
    self.startDateTime = startDateTime
7897 amar.kumar 17463 
    self.categoryId = categoryId
5944 mandeep.dh 17464 
 
17465 
  def read(self, iprot):
17466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17468 
      return
17469 
    iprot.readStructBegin()
17470 
    while True:
17471 
      (fname, ftype, fid) = iprot.readFieldBegin()
17472 
      if ftype == TType.STOP:
17473 
        break
17474 
      if fid == 1:
17475 
        if ftype == TType.I64:
17476 
          self.startDateTime = iprot.readI64();
17477 
        else:
17478 
          iprot.skip(ftype)
7897 amar.kumar 17479 
      elif fid == 2:
17480 
        if ftype == TType.I64:
17481 
          self.categoryId = iprot.readI64();
17482 
        else:
17483 
          iprot.skip(ftype)
5944 mandeep.dh 17484 
      else:
17485 
        iprot.skip(ftype)
17486 
      iprot.readFieldEnd()
17487 
    iprot.readStructEnd()
17488 
 
17489 
  def write(self, oprot):
17490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17492 
      return
17493 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
17494 
    if self.startDateTime is not None:
17495 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17496 
      oprot.writeI64(self.startDateTime)
17497 
      oprot.writeFieldEnd()
7897 amar.kumar 17498 
    if self.categoryId is not None:
17499 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
17500 
      oprot.writeI64(self.categoryId)
17501 
      oprot.writeFieldEnd()
5944 mandeep.dh 17502 
    oprot.writeFieldStop()
17503 
    oprot.writeStructEnd()
17504 
 
17505 
  def validate(self):
17506 
    return
17507 
 
17508 
 
17509 
  def __repr__(self):
17510 
    L = ['%s=%r' % (key, value)
17511 
      for key, value in self.__dict__.iteritems()]
17512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17513 
 
17514 
  def __eq__(self, other):
17515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17516 
 
17517 
  def __ne__(self, other):
17518 
    return not (self == other)
17519 
 
17520 
class getProductNotificationRequestCount_result:
17521 
  """
17522 
  Attributes:
17523 
   - success
17524 
  """
17525 
 
17526 
  thrift_spec = (
17527 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
17528 
  )
17529 
 
17530 
  def __init__(self, success=None,):
17531 
    self.success = success
17532 
 
17533 
  def read(self, iprot):
17534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17536 
      return
17537 
    iprot.readStructBegin()
17538 
    while True:
17539 
      (fname, ftype, fid) = iprot.readFieldBegin()
17540 
      if ftype == TType.STOP:
17541 
        break
17542 
      if fid == 0:
17543 
        if ftype == TType.LIST:
17544 
          self.success = []
9155 kshitij.so 17545 
          (_etype356, _size353) = iprot.readListBegin()
17546 
          for _i357 in xrange(_size353):
17547 
            _elem358 = ProductNotificationRequestCount()
17548 
            _elem358.read(iprot)
17549 
            self.success.append(_elem358)
5944 mandeep.dh 17550 
          iprot.readListEnd()
17551 
        else:
17552 
          iprot.skip(ftype)
17553 
      else:
17554 
        iprot.skip(ftype)
17555 
      iprot.readFieldEnd()
17556 
    iprot.readStructEnd()
17557 
 
17558 
  def write(self, oprot):
17559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17561 
      return
17562 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
17563 
    if self.success is not None:
17564 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17565 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17566 
      for iter359 in self.success:
17567 
        iter359.write(oprot)
5944 mandeep.dh 17568 
      oprot.writeListEnd()
17569 
      oprot.writeFieldEnd()
17570 
    oprot.writeFieldStop()
17571 
    oprot.writeStructEnd()
17572 
 
17573 
  def validate(self):
17574 
    return
17575 
 
17576 
 
17577 
  def __repr__(self):
17578 
    L = ['%s=%r' % (key, value)
17579 
      for key, value in self.__dict__.iteritems()]
17580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17581 
 
17582 
  def __eq__(self, other):
17583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17584 
 
17585 
  def __ne__(self, other):
17586 
    return not (self == other)
17587 
 
17588 
class addAuthorizationLog_args:
17589 
  """
17590 
  Attributes:
17591 
   - itemId
17592 
   - username
17593 
   - reason
17594 
  """
17595 
 
17596 
  thrift_spec = (
17597 
    None, # 0
17598 
    (1, TType.I64, 'itemId', None, None, ), # 1
17599 
    (2, TType.STRING, 'username', None, None, ), # 2
17600 
    (3, TType.STRING, 'reason', None, None, ), # 3
17601 
  )
17602 
 
17603 
  def __init__(self, itemId=None, username=None, reason=None,):
17604 
    self.itemId = itemId
17605 
    self.username = username
17606 
    self.reason = reason
17607 
 
17608 
  def read(self, iprot):
17609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17611 
      return
17612 
    iprot.readStructBegin()
17613 
    while True:
17614 
      (fname, ftype, fid) = iprot.readFieldBegin()
17615 
      if ftype == TType.STOP:
17616 
        break
17617 
      if fid == 1:
17618 
        if ftype == TType.I64:
17619 
          self.itemId = iprot.readI64();
17620 
        else:
17621 
          iprot.skip(ftype)
17622 
      elif fid == 2:
17623 
        if ftype == TType.STRING:
17624 
          self.username = iprot.readString();
17625 
        else:
17626 
          iprot.skip(ftype)
17627 
      elif fid == 3:
17628 
        if ftype == TType.STRING:
17629 
          self.reason = iprot.readString();
17630 
        else:
17631 
          iprot.skip(ftype)
17632 
      else:
17633 
        iprot.skip(ftype)
17634 
      iprot.readFieldEnd()
17635 
    iprot.readStructEnd()
17636 
 
17637 
  def write(self, oprot):
17638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17640 
      return
17641 
    oprot.writeStructBegin('addAuthorizationLog_args')
17642 
    if self.itemId is not None:
17643 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17644 
      oprot.writeI64(self.itemId)
17645 
      oprot.writeFieldEnd()
17646 
    if self.username is not None:
17647 
      oprot.writeFieldBegin('username', TType.STRING, 2)
17648 
      oprot.writeString(self.username)
17649 
      oprot.writeFieldEnd()
17650 
    if self.reason is not None:
17651 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17652 
      oprot.writeString(self.reason)
17653 
      oprot.writeFieldEnd()
17654 
    oprot.writeFieldStop()
17655 
    oprot.writeStructEnd()
17656 
 
17657 
  def validate(self):
17658 
    return
17659 
 
17660 
 
17661 
  def __repr__(self):
17662 
    L = ['%s=%r' % (key, value)
17663 
      for key, value in self.__dict__.iteritems()]
17664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17665 
 
17666 
  def __eq__(self, other):
17667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17668 
 
17669 
  def __ne__(self, other):
17670 
    return not (self == other)
17671 
 
17672 
class addAuthorizationLog_result:
17673 
  """
17674 
  Attributes:
17675 
   - success
17676 
   - cex
17677 
  """
17678 
 
17679 
  thrift_spec = (
17680 
    (0, TType.BOOL, 'success', None, None, ), # 0
17681 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17682 
  )
17683 
 
17684 
  def __init__(self, success=None, cex=None,):
17685 
    self.success = success
17686 
    self.cex = cex
17687 
 
17688 
  def read(self, iprot):
17689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17691 
      return
17692 
    iprot.readStructBegin()
17693 
    while True:
17694 
      (fname, ftype, fid) = iprot.readFieldBegin()
17695 
      if ftype == TType.STOP:
17696 
        break
17697 
      if fid == 0:
17698 
        if ftype == TType.BOOL:
17699 
          self.success = iprot.readBool();
17700 
        else:
17701 
          iprot.skip(ftype)
17702 
      elif fid == 1:
17703 
        if ftype == TType.STRUCT:
17704 
          self.cex = CatalogServiceException()
17705 
          self.cex.read(iprot)
17706 
        else:
17707 
          iprot.skip(ftype)
17708 
      else:
17709 
        iprot.skip(ftype)
17710 
      iprot.readFieldEnd()
17711 
    iprot.readStructEnd()
17712 
 
17713 
  def write(self, oprot):
17714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17716 
      return
17717 
    oprot.writeStructBegin('addAuthorizationLog_result')
17718 
    if self.success is not None:
17719 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17720 
      oprot.writeBool(self.success)
17721 
      oprot.writeFieldEnd()
17722 
    if self.cex is not None:
17723 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17724 
      self.cex.write(oprot)
17725 
      oprot.writeFieldEnd()
17726 
    oprot.writeFieldStop()
17727 
    oprot.writeStructEnd()
17728 
 
17729 
  def validate(self):
17730 
    return
17731 
 
17732 
 
17733 
  def __repr__(self):
17734 
    L = ['%s=%r' % (key, value)
17735 
      for key, value in self.__dict__.iteritems()]
17736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17737 
 
17738 
  def __eq__(self, other):
17739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17740 
 
17741 
  def __ne__(self, other):
17742 
    return not (self == other)
17743 
 
17744 
class addupdateVoucherForItem_args:
17745 
  """
17746 
  Attributes:
17747 
   - catalog_item_id
17748 
   - voucherType
17749 
   - voucherAmount
17750 
  """
17751 
 
17752 
  thrift_spec = (
17753 
    None, # 0
17754 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17755 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17756 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
17757 
  )
17758 
 
17759 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
17760 
    self.catalog_item_id = catalog_item_id
17761 
    self.voucherType = voucherType
17762 
    self.voucherAmount = voucherAmount
17763 
 
17764 
  def read(self, iprot):
17765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17767 
      return
17768 
    iprot.readStructBegin()
17769 
    while True:
17770 
      (fname, ftype, fid) = iprot.readFieldBegin()
17771 
      if ftype == TType.STOP:
17772 
        break
17773 
      if fid == 1:
17774 
        if ftype == TType.I64:
17775 
          self.catalog_item_id = iprot.readI64();
17776 
        else:
17777 
          iprot.skip(ftype)
17778 
      elif fid == 2:
17779 
        if ftype == TType.I64:
17780 
          self.voucherType = iprot.readI64();
17781 
        else:
17782 
          iprot.skip(ftype)
17783 
      elif fid == 3:
17784 
        if ftype == TType.I64:
17785 
          self.voucherAmount = iprot.readI64();
17786 
        else:
17787 
          iprot.skip(ftype)
17788 
      else:
17789 
        iprot.skip(ftype)
17790 
      iprot.readFieldEnd()
17791 
    iprot.readStructEnd()
17792 
 
17793 
  def write(self, oprot):
17794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17796 
      return
17797 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
17798 
    if self.catalog_item_id is not None:
17799 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17800 
      oprot.writeI64(self.catalog_item_id)
17801 
      oprot.writeFieldEnd()
17802 
    if self.voucherType is not None:
17803 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17804 
      oprot.writeI64(self.voucherType)
17805 
      oprot.writeFieldEnd()
17806 
    if self.voucherAmount is not None:
17807 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
17808 
      oprot.writeI64(self.voucherAmount)
17809 
      oprot.writeFieldEnd()
17810 
    oprot.writeFieldStop()
17811 
    oprot.writeStructEnd()
17812 
 
17813 
  def validate(self):
17814 
    return
17815 
 
17816 
 
17817 
  def __repr__(self):
17818 
    L = ['%s=%r' % (key, value)
17819 
      for key, value in self.__dict__.iteritems()]
17820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17821 
 
17822 
  def __eq__(self, other):
17823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17824 
 
17825 
  def __ne__(self, other):
17826 
    return not (self == other)
17827 
 
17828 
class addupdateVoucherForItem_result:
17829 
  """
17830 
  Attributes:
17831 
   - success
17832 
   - cex
17833 
  """
17834 
 
17835 
  thrift_spec = (
17836 
    (0, TType.BOOL, 'success', None, None, ), # 0
17837 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17838 
  )
17839 
 
17840 
  def __init__(self, success=None, cex=None,):
17841 
    self.success = success
17842 
    self.cex = cex
17843 
 
17844 
  def read(self, iprot):
17845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17847 
      return
17848 
    iprot.readStructBegin()
17849 
    while True:
17850 
      (fname, ftype, fid) = iprot.readFieldBegin()
17851 
      if ftype == TType.STOP:
17852 
        break
17853 
      if fid == 0:
17854 
        if ftype == TType.BOOL:
17855 
          self.success = iprot.readBool();
17856 
        else:
17857 
          iprot.skip(ftype)
17858 
      elif fid == 1:
17859 
        if ftype == TType.STRUCT:
17860 
          self.cex = CatalogServiceException()
17861 
          self.cex.read(iprot)
17862 
        else:
17863 
          iprot.skip(ftype)
17864 
      else:
17865 
        iprot.skip(ftype)
17866 
      iprot.readFieldEnd()
17867 
    iprot.readStructEnd()
17868 
 
17869 
  def write(self, oprot):
17870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17872 
      return
17873 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
17874 
    if self.success is not None:
17875 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17876 
      oprot.writeBool(self.success)
17877 
      oprot.writeFieldEnd()
17878 
    if self.cex is not None:
17879 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17880 
      self.cex.write(oprot)
17881 
      oprot.writeFieldEnd()
17882 
    oprot.writeFieldStop()
17883 
    oprot.writeStructEnd()
17884 
 
17885 
  def validate(self):
17886 
    return
17887 
 
17888 
 
17889 
  def __repr__(self):
17890 
    L = ['%s=%r' % (key, value)
17891 
      for key, value in self.__dict__.iteritems()]
17892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17893 
 
17894 
  def __eq__(self, other):
17895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17896 
 
17897 
  def __ne__(self, other):
17898 
    return not (self == other)
17899 
 
17900 
class deleteVoucherForItem_args:
17901 
  """
17902 
  Attributes:
17903 
   - catalog_item_id
17904 
   - voucherType
17905 
  """
17906 
 
17907 
  thrift_spec = (
17908 
    None, # 0
17909 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17910 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17911 
  )
17912 
 
17913 
  def __init__(self, catalog_item_id=None, voucherType=None,):
17914 
    self.catalog_item_id = catalog_item_id
17915 
    self.voucherType = voucherType
17916 
 
17917 
  def read(self, iprot):
17918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17920 
      return
17921 
    iprot.readStructBegin()
17922 
    while True:
17923 
      (fname, ftype, fid) = iprot.readFieldBegin()
17924 
      if ftype == TType.STOP:
17925 
        break
17926 
      if fid == 1:
17927 
        if ftype == TType.I64:
17928 
          self.catalog_item_id = iprot.readI64();
17929 
        else:
17930 
          iprot.skip(ftype)
17931 
      elif fid == 2:
17932 
        if ftype == TType.I64:
17933 
          self.voucherType = iprot.readI64();
17934 
        else:
17935 
          iprot.skip(ftype)
17936 
      else:
17937 
        iprot.skip(ftype)
17938 
      iprot.readFieldEnd()
17939 
    iprot.readStructEnd()
17940 
 
17941 
  def write(self, oprot):
17942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17944 
      return
17945 
    oprot.writeStructBegin('deleteVoucherForItem_args')
17946 
    if self.catalog_item_id is not None:
17947 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17948 
      oprot.writeI64(self.catalog_item_id)
17949 
      oprot.writeFieldEnd()
17950 
    if self.voucherType is not None:
17951 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17952 
      oprot.writeI64(self.voucherType)
17953 
      oprot.writeFieldEnd()
17954 
    oprot.writeFieldStop()
17955 
    oprot.writeStructEnd()
17956 
 
17957 
  def validate(self):
17958 
    return
17959 
 
17960 
 
17961 
  def __repr__(self):
17962 
    L = ['%s=%r' % (key, value)
17963 
      for key, value in self.__dict__.iteritems()]
17964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17965 
 
17966 
  def __eq__(self, other):
17967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17968 
 
17969 
  def __ne__(self, other):
17970 
    return not (self == other)
17971 
 
17972 
class deleteVoucherForItem_result:
17973 
  """
17974 
  Attributes:
17975 
   - success
17976 
   - cex
17977 
  """
17978 
 
17979 
  thrift_spec = (
17980 
    (0, TType.BOOL, 'success', None, None, ), # 0
17981 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17982 
  )
17983 
 
17984 
  def __init__(self, success=None, cex=None,):
17985 
    self.success = success
17986 
    self.cex = cex
17987 
 
17988 
  def read(self, iprot):
17989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17991 
      return
17992 
    iprot.readStructBegin()
17993 
    while True:
17994 
      (fname, ftype, fid) = iprot.readFieldBegin()
17995 
      if ftype == TType.STOP:
17996 
        break
17997 
      if fid == 0:
17998 
        if ftype == TType.BOOL:
17999 
          self.success = iprot.readBool();
18000 
        else:
18001 
          iprot.skip(ftype)
18002 
      elif fid == 1:
18003 
        if ftype == TType.STRUCT:
18004 
          self.cex = CatalogServiceException()
18005 
          self.cex.read(iprot)
18006 
        else:
18007 
          iprot.skip(ftype)
18008 
      else:
18009 
        iprot.skip(ftype)
18010 
      iprot.readFieldEnd()
18011 
    iprot.readStructEnd()
18012 
 
18013 
  def write(self, oprot):
18014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18016 
      return
18017 
    oprot.writeStructBegin('deleteVoucherForItem_result')
18018 
    if self.success is not None:
18019 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18020 
      oprot.writeBool(self.success)
18021 
      oprot.writeFieldEnd()
18022 
    if self.cex is not None:
18023 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18024 
      self.cex.write(oprot)
18025 
      oprot.writeFieldEnd()
18026 
    oprot.writeFieldStop()
18027 
    oprot.writeStructEnd()
18028 
 
18029 
  def validate(self):
18030 
    return
18031 
 
18032 
 
18033 
  def __repr__(self):
18034 
    L = ['%s=%r' % (key, value)
18035 
      for key, value in self.__dict__.iteritems()]
18036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18037 
 
18038 
  def __eq__(self, other):
18039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18040 
 
18041 
  def __ne__(self, other):
18042 
    return not (self == other)
18043 
 
18044 
class getVoucherAmount_args:
18045 
  """
18046 
  Attributes:
18047 
   - itemId
18048 
   - voucherType
18049 
  """
18050 
 
18051 
  thrift_spec = (
18052 
    None, # 0
18053 
    (1, TType.I64, 'itemId', None, None, ), # 1
18054 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18055 
  )
18056 
 
18057 
  def __init__(self, itemId=None, voucherType=None,):
18058 
    self.itemId = itemId
18059 
    self.voucherType = voucherType
18060 
 
18061 
  def read(self, iprot):
18062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18064 
      return
18065 
    iprot.readStructBegin()
18066 
    while True:
18067 
      (fname, ftype, fid) = iprot.readFieldBegin()
18068 
      if ftype == TType.STOP:
18069 
        break
18070 
      if fid == 1:
18071 
        if ftype == TType.I64:
18072 
          self.itemId = iprot.readI64();
18073 
        else:
18074 
          iprot.skip(ftype)
18075 
      elif fid == 2:
18076 
        if ftype == TType.I64:
18077 
          self.voucherType = iprot.readI64();
18078 
        else:
18079 
          iprot.skip(ftype)
18080 
      else:
18081 
        iprot.skip(ftype)
18082 
      iprot.readFieldEnd()
18083 
    iprot.readStructEnd()
18084 
 
18085 
  def write(self, oprot):
18086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18088 
      return
18089 
    oprot.writeStructBegin('getVoucherAmount_args')
18090 
    if self.itemId is not None:
18091 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18092 
      oprot.writeI64(self.itemId)
18093 
      oprot.writeFieldEnd()
18094 
    if self.voucherType is not None:
18095 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18096 
      oprot.writeI64(self.voucherType)
18097 
      oprot.writeFieldEnd()
18098 
    oprot.writeFieldStop()
18099 
    oprot.writeStructEnd()
18100 
 
18101 
  def validate(self):
18102 
    return
18103 
 
18104 
 
18105 
  def __repr__(self):
18106 
    L = ['%s=%r' % (key, value)
18107 
      for key, value in self.__dict__.iteritems()]
18108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18109 
 
18110 
  def __eq__(self, other):
18111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18112 
 
18113 
  def __ne__(self, other):
18114 
    return not (self == other)
18115 
 
18116 
class getVoucherAmount_result:
18117 
  """
18118 
  Attributes:
18119 
   - success
18120 
  """
18121 
 
18122 
  thrift_spec = (
18123 
    (0, TType.I64, 'success', None, None, ), # 0
18124 
  )
18125 
 
18126 
  def __init__(self, success=None,):
18127 
    self.success = success
18128 
 
18129 
  def read(self, iprot):
18130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18132 
      return
18133 
    iprot.readStructBegin()
18134 
    while True:
18135 
      (fname, ftype, fid) = iprot.readFieldBegin()
18136 
      if ftype == TType.STOP:
18137 
        break
18138 
      if fid == 0:
18139 
        if ftype == TType.I64:
18140 
          self.success = iprot.readI64();
18141 
        else:
18142 
          iprot.skip(ftype)
18143 
      else:
18144 
        iprot.skip(ftype)
18145 
      iprot.readFieldEnd()
18146 
    iprot.readStructEnd()
18147 
 
18148 
  def write(self, oprot):
18149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18151 
      return
18152 
    oprot.writeStructBegin('getVoucherAmount_result')
18153 
    if self.success is not None:
18154 
      oprot.writeFieldBegin('success', TType.I64, 0)
18155 
      oprot.writeI64(self.success)
18156 
      oprot.writeFieldEnd()
18157 
    oprot.writeFieldStop()
18158 
    oprot.writeStructEnd()
18159 
 
18160 
  def validate(self):
18161 
    return
18162 
 
18163 
 
18164 
  def __repr__(self):
18165 
    L = ['%s=%r' % (key, value)
18166 
      for key, value in self.__dict__.iteritems()]
18167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18168 
 
18169 
  def __eq__(self, other):
18170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18171 
 
18172 
  def __ne__(self, other):
18173 
    return not (self == other)
18174 
 
18175 
class getAllItemVouchers_args:
18176 
  """
18177 
  Attributes:
18178 
   - itemId
18179 
  """
18180 
 
18181 
  thrift_spec = (
18182 
    None, # 0
18183 
    (1, TType.I64, 'itemId', None, None, ), # 1
18184 
  )
18185 
 
18186 
  def __init__(self, itemId=None,):
18187 
    self.itemId = itemId
18188 
 
18189 
  def read(self, iprot):
18190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18192 
      return
18193 
    iprot.readStructBegin()
18194 
    while True:
18195 
      (fname, ftype, fid) = iprot.readFieldBegin()
18196 
      if ftype == TType.STOP:
18197 
        break
18198 
      if fid == 1:
18199 
        if ftype == TType.I64:
18200 
          self.itemId = iprot.readI64();
18201 
        else:
18202 
          iprot.skip(ftype)
18203 
      else:
18204 
        iprot.skip(ftype)
18205 
      iprot.readFieldEnd()
18206 
    iprot.readStructEnd()
18207 
 
18208 
  def write(self, oprot):
18209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18211 
      return
18212 
    oprot.writeStructBegin('getAllItemVouchers_args')
18213 
    if self.itemId is not None:
18214 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18215 
      oprot.writeI64(self.itemId)
18216 
      oprot.writeFieldEnd()
18217 
    oprot.writeFieldStop()
18218 
    oprot.writeStructEnd()
18219 
 
18220 
  def validate(self):
18221 
    return
18222 
 
18223 
 
18224 
  def __repr__(self):
18225 
    L = ['%s=%r' % (key, value)
18226 
      for key, value in self.__dict__.iteritems()]
18227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18228 
 
18229 
  def __eq__(self, other):
18230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18231 
 
18232 
  def __ne__(self, other):
18233 
    return not (self == other)
18234 
 
18235 
class getAllItemVouchers_result:
18236 
  """
18237 
  Attributes:
18238 
   - success
18239 
  """
18240 
 
18241 
  thrift_spec = (
18242 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
18243 
  )
18244 
 
18245 
  def __init__(self, success=None,):
18246 
    self.success = success
18247 
 
18248 
  def read(self, iprot):
18249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18251 
      return
18252 
    iprot.readStructBegin()
18253 
    while True:
18254 
      (fname, ftype, fid) = iprot.readFieldBegin()
18255 
      if ftype == TType.STOP:
18256 
        break
18257 
      if fid == 0:
18258 
        if ftype == TType.LIST:
18259 
          self.success = []
9155 kshitij.so 18260 
          (_etype363, _size360) = iprot.readListBegin()
18261 
          for _i364 in xrange(_size360):
18262 
            _elem365 = VoucherItemMapping()
18263 
            _elem365.read(iprot)
18264 
            self.success.append(_elem365)
5944 mandeep.dh 18265 
          iprot.readListEnd()
18266 
        else:
18267 
          iprot.skip(ftype)
18268 
      else:
18269 
        iprot.skip(ftype)
18270 
      iprot.readFieldEnd()
18271 
    iprot.readStructEnd()
18272 
 
18273 
  def write(self, oprot):
18274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18276 
      return
18277 
    oprot.writeStructBegin('getAllItemVouchers_result')
18278 
    if self.success is not None:
18279 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18280 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18281 
      for iter366 in self.success:
18282 
        iter366.write(oprot)
5944 mandeep.dh 18283 
      oprot.writeListEnd()
18284 
      oprot.writeFieldEnd()
18285 
    oprot.writeFieldStop()
18286 
    oprot.writeStructEnd()
18287 
 
18288 
  def validate(self):
18289 
    return
18290 
 
18291 
 
18292 
  def __repr__(self):
18293 
    L = ['%s=%r' % (key, value)
18294 
      for key, value in self.__dict__.iteritems()]
18295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18296 
 
18297 
  def __eq__(self, other):
18298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18299 
 
18300 
  def __ne__(self, other):
18301 
    return not (self == other)
18302 
 
18303 
class isValidCatalogItemId_args:
18304 
  """
18305 
  Attributes:
18306 
   - catalog_item_id
18307 
  """
18308 
 
18309 
  thrift_spec = (
18310 
    None, # 0
18311 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18312 
  )
18313 
 
18314 
  def __init__(self, catalog_item_id=None,):
18315 
    self.catalog_item_id = catalog_item_id
18316 
 
18317 
  def read(self, iprot):
18318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18320 
      return
18321 
    iprot.readStructBegin()
18322 
    while True:
18323 
      (fname, ftype, fid) = iprot.readFieldBegin()
18324 
      if ftype == TType.STOP:
18325 
        break
18326 
      if fid == 1:
18327 
        if ftype == TType.I64:
18328 
          self.catalog_item_id = iprot.readI64();
18329 
        else:
18330 
          iprot.skip(ftype)
18331 
      else:
18332 
        iprot.skip(ftype)
18333 
      iprot.readFieldEnd()
18334 
    iprot.readStructEnd()
18335 
 
18336 
  def write(self, oprot):
18337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18339 
      return
18340 
    oprot.writeStructBegin('isValidCatalogItemId_args')
18341 
    if self.catalog_item_id is not None:
18342 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18343 
      oprot.writeI64(self.catalog_item_id)
18344 
      oprot.writeFieldEnd()
18345 
    oprot.writeFieldStop()
18346 
    oprot.writeStructEnd()
18347 
 
18348 
  def validate(self):
18349 
    return
18350 
 
18351 
 
18352 
  def __repr__(self):
18353 
    L = ['%s=%r' % (key, value)
18354 
      for key, value in self.__dict__.iteritems()]
18355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18356 
 
18357 
  def __eq__(self, other):
18358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18359 
 
18360 
  def __ne__(self, other):
18361 
    return not (self == other)
18362 
 
18363 
class isValidCatalogItemId_result:
18364 
  """
18365 
  Attributes:
18366 
   - success
18367 
  """
18368 
 
18369 
  thrift_spec = (
18370 
    (0, TType.BOOL, 'success', None, None, ), # 0
18371 
  )
18372 
 
18373 
  def __init__(self, success=None,):
18374 
    self.success = success
18375 
 
18376 
  def read(self, iprot):
18377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18379 
      return
18380 
    iprot.readStructBegin()
18381 
    while True:
18382 
      (fname, ftype, fid) = iprot.readFieldBegin()
18383 
      if ftype == TType.STOP:
18384 
        break
18385 
      if fid == 0:
18386 
        if ftype == TType.BOOL:
18387 
          self.success = iprot.readBool();
18388 
        else:
18389 
          iprot.skip(ftype)
18390 
      else:
18391 
        iprot.skip(ftype)
18392 
      iprot.readFieldEnd()
18393 
    iprot.readStructEnd()
18394 
 
18395 
  def write(self, oprot):
18396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18398 
      return
18399 
    oprot.writeStructBegin('isValidCatalogItemId_result')
18400 
    if self.success is not None:
18401 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18402 
      oprot.writeBool(self.success)
18403 
      oprot.writeFieldEnd()
18404 
    oprot.writeFieldStop()
18405 
    oprot.writeStructEnd()
18406 
 
18407 
  def validate(self):
18408 
    return
18409 
 
18410 
 
18411 
  def __repr__(self):
18412 
    L = ['%s=%r' % (key, value)
18413 
      for key, value in self.__dict__.iteritems()]
18414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18415 
 
18416 
  def __eq__(self, other):
18417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18418 
 
18419 
  def __ne__(self, other):
18420 
    return not (self == other)
6039 amit.gupta 18421 
 
18422 
class getVatPercentageForItem_args:
18423 
  """
18424 
  Attributes:
18425 
   - itemId
7330 amit.gupta 18426 
   - stateId
6039 amit.gupta 18427 
   - price
18428 
  """
18429 
 
18430 
  thrift_spec = (
18431 
    None, # 0
18432 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 18433 
    (2, TType.I64, 'stateId', None, None, ), # 2
18434 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 18435 
  )
18436 
 
7330 amit.gupta 18437 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 18438 
    self.itemId = itemId
7330 amit.gupta 18439 
    self.stateId = stateId
6039 amit.gupta 18440 
    self.price = price
18441 
 
18442 
  def read(self, iprot):
18443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18445 
      return
18446 
    iprot.readStructBegin()
18447 
    while True:
18448 
      (fname, ftype, fid) = iprot.readFieldBegin()
18449 
      if ftype == TType.STOP:
18450 
        break
18451 
      if fid == 1:
18452 
        if ftype == TType.I64:
18453 
          self.itemId = iprot.readI64();
18454 
        else:
18455 
          iprot.skip(ftype)
18456 
      elif fid == 2:
7330 amit.gupta 18457 
        if ftype == TType.I64:
18458 
          self.stateId = iprot.readI64();
18459 
        else:
18460 
          iprot.skip(ftype)
18461 
      elif fid == 3:
6039 amit.gupta 18462 
        if ftype == TType.DOUBLE:
18463 
          self.price = iprot.readDouble();
18464 
        else:
18465 
          iprot.skip(ftype)
18466 
      else:
18467 
        iprot.skip(ftype)
18468 
      iprot.readFieldEnd()
18469 
    iprot.readStructEnd()
18470 
 
18471 
  def write(self, oprot):
18472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18474 
      return
18475 
    oprot.writeStructBegin('getVatPercentageForItem_args')
18476 
    if self.itemId is not None:
18477 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18478 
      oprot.writeI64(self.itemId)
18479 
      oprot.writeFieldEnd()
7330 amit.gupta 18480 
    if self.stateId is not None:
18481 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
18482 
      oprot.writeI64(self.stateId)
18483 
      oprot.writeFieldEnd()
6039 amit.gupta 18484 
    if self.price is not None:
7330 amit.gupta 18485 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 18486 
      oprot.writeDouble(self.price)
18487 
      oprot.writeFieldEnd()
18488 
    oprot.writeFieldStop()
18489 
    oprot.writeStructEnd()
18490 
 
18491 
  def validate(self):
18492 
    return
18493 
 
18494 
 
18495 
  def __repr__(self):
18496 
    L = ['%s=%r' % (key, value)
18497 
      for key, value in self.__dict__.iteritems()]
18498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18499 
 
18500 
  def __eq__(self, other):
18501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18502 
 
18503 
  def __ne__(self, other):
18504 
    return not (self == other)
18505 
 
18506 
class getVatPercentageForItem_result:
18507 
  """
18508 
  Attributes:
18509 
   - success
7340 amit.gupta 18510 
   - cex
6039 amit.gupta 18511 
  """
18512 
 
18513 
  thrift_spec = (
18514 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 18515 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 18516 
  )
18517 
 
7340 amit.gupta 18518 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 18519 
    self.success = success
7340 amit.gupta 18520 
    self.cex = cex
6039 amit.gupta 18521 
 
18522 
  def read(self, iprot):
18523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18525 
      return
18526 
    iprot.readStructBegin()
18527 
    while True:
18528 
      (fname, ftype, fid) = iprot.readFieldBegin()
18529 
      if ftype == TType.STOP:
18530 
        break
18531 
      if fid == 0:
18532 
        if ftype == TType.DOUBLE:
18533 
          self.success = iprot.readDouble();
18534 
        else:
18535 
          iprot.skip(ftype)
7340 amit.gupta 18536 
      elif fid == 1:
18537 
        if ftype == TType.STRUCT:
18538 
          self.cex = CatalogServiceException()
18539 
          self.cex.read(iprot)
18540 
        else:
18541 
          iprot.skip(ftype)
6039 amit.gupta 18542 
      else:
18543 
        iprot.skip(ftype)
18544 
      iprot.readFieldEnd()
18545 
    iprot.readStructEnd()
18546 
 
18547 
  def write(self, oprot):
18548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18550 
      return
18551 
    oprot.writeStructBegin('getVatPercentageForItem_result')
18552 
    if self.success is not None:
18553 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
18554 
      oprot.writeDouble(self.success)
18555 
      oprot.writeFieldEnd()
7340 amit.gupta 18556 
    if self.cex is not None:
18557 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18558 
      self.cex.write(oprot)
18559 
      oprot.writeFieldEnd()
6039 amit.gupta 18560 
    oprot.writeFieldStop()
18561 
    oprot.writeStructEnd()
18562 
 
18563 
  def validate(self):
18564 
    return
18565 
 
18566 
 
18567 
  def __repr__(self):
18568 
    L = ['%s=%r' % (key, value)
18569 
      for key, value in self.__dict__.iteritems()]
18570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18571 
 
18572 
  def __eq__(self, other):
18573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18574 
 
18575 
  def __ne__(self, other):
18576 
    return not (self == other)
18577 
 
18578 
class getVatAmountForItem_args:
18579 
  """
18580 
  Attributes:
18581 
   - itemId
18582 
   - price
18583 
  """
18584 
 
18585 
  thrift_spec = (
18586 
    None, # 0
18587 
    (1, TType.I64, 'itemId', None, None, ), # 1
18588 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18589 
  )
18590 
 
18591 
  def __init__(self, itemId=None, price=None,):
18592 
    self.itemId = itemId
18593 
    self.price = price
18594 
 
18595 
  def read(self, iprot):
18596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18598 
      return
18599 
    iprot.readStructBegin()
18600 
    while True:
18601 
      (fname, ftype, fid) = iprot.readFieldBegin()
18602 
      if ftype == TType.STOP:
18603 
        break
18604 
      if fid == 1:
18605 
        if ftype == TType.I64:
18606 
          self.itemId = iprot.readI64();
18607 
        else:
18608 
          iprot.skip(ftype)
18609 
      elif fid == 2:
18610 
        if ftype == TType.DOUBLE:
18611 
          self.price = iprot.readDouble();
18612 
        else:
18613 
          iprot.skip(ftype)
18614 
      else:
18615 
        iprot.skip(ftype)
18616 
      iprot.readFieldEnd()
18617 
    iprot.readStructEnd()
18618 
 
18619 
  def write(self, oprot):
18620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18622 
      return
18623 
    oprot.writeStructBegin('getVatAmountForItem_args')
18624 
    if self.itemId is not None:
18625 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18626 
      oprot.writeI64(self.itemId)
18627 
      oprot.writeFieldEnd()
18628 
    if self.price is not None:
18629 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18630 
      oprot.writeDouble(self.price)
18631 
      oprot.writeFieldEnd()
18632 
    oprot.writeFieldStop()
18633 
    oprot.writeStructEnd()
18634 
 
18635 
  def validate(self):
18636 
    return
18637 
 
18638 
 
18639 
  def __repr__(self):
18640 
    L = ['%s=%r' % (key, value)
18641 
      for key, value in self.__dict__.iteritems()]
18642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18643 
 
18644 
  def __eq__(self, other):
18645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18646 
 
18647 
  def __ne__(self, other):
18648 
    return not (self == other)
18649 
 
18650 
class getVatAmountForItem_result:
18651 
  """
18652 
  Attributes:
18653 
   - success
18654 
  """
18655 
 
18656 
  thrift_spec = (
18657 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
18658 
  )
18659 
 
18660 
  def __init__(self, success=None,):
18661 
    self.success = success
18662 
 
18663 
  def read(self, iprot):
18664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18666 
      return
18667 
    iprot.readStructBegin()
18668 
    while True:
18669 
      (fname, ftype, fid) = iprot.readFieldBegin()
18670 
      if ftype == TType.STOP:
18671 
        break
18672 
      if fid == 0:
18673 
        if ftype == TType.DOUBLE:
18674 
          self.success = iprot.readDouble();
18675 
        else:
18676 
          iprot.skip(ftype)
18677 
      else:
18678 
        iprot.skip(ftype)
18679 
      iprot.readFieldEnd()
18680 
    iprot.readStructEnd()
18681 
 
18682 
  def write(self, oprot):
18683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18685 
      return
18686 
    oprot.writeStructBegin('getVatAmountForItem_result')
18687 
    if self.success is not None:
18688 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
18689 
      oprot.writeDouble(self.success)
18690 
      oprot.writeFieldEnd()
18691 
    oprot.writeFieldStop()
18692 
    oprot.writeStructEnd()
18693 
 
18694 
  def validate(self):
18695 
    return
18696 
 
18697 
 
18698 
  def __repr__(self):
18699 
    L = ['%s=%r' % (key, value)
18700 
      for key, value in self.__dict__.iteritems()]
18701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18702 
 
18703 
  def __eq__(self, other):
18704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18705 
 
18706 
  def __ne__(self, other):
18707 
    return not (self == other)
6531 vikram.rag 18708 
 
18709 
class getAllIgnoredInventoryUpdateItemsList_args:
18710 
  """
18711 
  Attributes:
18712 
   - offset
18713 
   - limit
18714 
  """
18715 
 
18716 
  thrift_spec = (
18717 
    None, # 0
18718 
    (1, TType.I32, 'offset', None, None, ), # 1
18719 
    (2, TType.I32, 'limit', None, None, ), # 2
18720 
  )
18721 
 
18722 
  def __init__(self, offset=None, limit=None,):
18723 
    self.offset = offset
18724 
    self.limit = limit
18725 
 
18726 
  def read(self, iprot):
18727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18729 
      return
18730 
    iprot.readStructBegin()
18731 
    while True:
18732 
      (fname, ftype, fid) = iprot.readFieldBegin()
18733 
      if ftype == TType.STOP:
18734 
        break
18735 
      if fid == 1:
18736 
        if ftype == TType.I32:
18737 
          self.offset = iprot.readI32();
18738 
        else:
18739 
          iprot.skip(ftype)
18740 
      elif fid == 2:
18741 
        if ftype == TType.I32:
18742 
          self.limit = iprot.readI32();
18743 
        else:
18744 
          iprot.skip(ftype)
18745 
      else:
18746 
        iprot.skip(ftype)
18747 
      iprot.readFieldEnd()
18748 
    iprot.readStructEnd()
18749 
 
18750 
  def write(self, oprot):
18751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18753 
      return
18754 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
18755 
    if self.offset is not None:
18756 
      oprot.writeFieldBegin('offset', TType.I32, 1)
18757 
      oprot.writeI32(self.offset)
18758 
      oprot.writeFieldEnd()
18759 
    if self.limit is not None:
18760 
      oprot.writeFieldBegin('limit', TType.I32, 2)
18761 
      oprot.writeI32(self.limit)
18762 
      oprot.writeFieldEnd()
18763 
    oprot.writeFieldStop()
18764 
    oprot.writeStructEnd()
18765 
 
18766 
  def validate(self):
18767 
    return
18768 
 
18769 
 
18770 
  def __repr__(self):
18771 
    L = ['%s=%r' % (key, value)
18772 
      for key, value in self.__dict__.iteritems()]
18773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18774 
 
18775 
  def __eq__(self, other):
18776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18777 
 
18778 
  def __ne__(self, other):
18779 
    return not (self == other)
18780 
 
18781 
class getAllIgnoredInventoryUpdateItemsList_result:
18782 
  """
18783 
  Attributes:
18784 
   - success
18785 
  """
18786 
 
18787 
  thrift_spec = (
18788 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18789 
  )
18790 
 
18791 
  def __init__(self, success=None,):
18792 
    self.success = success
18793 
 
18794 
  def read(self, iprot):
18795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18797 
      return
18798 
    iprot.readStructBegin()
18799 
    while True:
18800 
      (fname, ftype, fid) = iprot.readFieldBegin()
18801 
      if ftype == TType.STOP:
18802 
        break
18803 
      if fid == 0:
18804 
        if ftype == TType.LIST:
18805 
          self.success = []
9155 kshitij.so 18806 
          (_etype370, _size367) = iprot.readListBegin()
18807 
          for _i371 in xrange(_size367):
18808 
            _elem372 = Item()
18809 
            _elem372.read(iprot)
18810 
            self.success.append(_elem372)
6531 vikram.rag 18811 
          iprot.readListEnd()
18812 
        else:
18813 
          iprot.skip(ftype)
18814 
      else:
18815 
        iprot.skip(ftype)
18816 
      iprot.readFieldEnd()
18817 
    iprot.readStructEnd()
18818 
 
18819 
  def write(self, oprot):
18820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18822 
      return
18823 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
18824 
    if self.success is not None:
18825 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18826 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18827 
      for iter373 in self.success:
18828 
        iter373.write(oprot)
6531 vikram.rag 18829 
      oprot.writeListEnd()
18830 
      oprot.writeFieldEnd()
18831 
    oprot.writeFieldStop()
18832 
    oprot.writeStructEnd()
18833 
 
18834 
  def validate(self):
18835 
    return
18836 
 
18837 
 
18838 
  def __repr__(self):
18839 
    L = ['%s=%r' % (key, value)
18840 
      for key, value in self.__dict__.iteritems()]
18841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18842 
 
18843 
  def __eq__(self, other):
18844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18845 
 
18846 
  def __ne__(self, other):
18847 
    return not (self == other)
6805 anupam.sin 18848 
 
6821 amar.kumar 18849 
class getAllAliveItems_args:
18850 
 
18851 
  thrift_spec = (
18852 
  )
18853 
 
18854 
  def read(self, iprot):
18855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18857 
      return
18858 
    iprot.readStructBegin()
18859 
    while True:
18860 
      (fname, ftype, fid) = iprot.readFieldBegin()
18861 
      if ftype == TType.STOP:
18862 
        break
18863 
      else:
18864 
        iprot.skip(ftype)
18865 
      iprot.readFieldEnd()
18866 
    iprot.readStructEnd()
18867 
 
18868 
  def write(self, oprot):
18869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18871 
      return
18872 
    oprot.writeStructBegin('getAllAliveItems_args')
18873 
    oprot.writeFieldStop()
18874 
    oprot.writeStructEnd()
18875 
 
18876 
  def validate(self):
18877 
    return
18878 
 
18879 
 
18880 
  def __repr__(self):
18881 
    L = ['%s=%r' % (key, value)
18882 
      for key, value in self.__dict__.iteritems()]
18883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18884 
 
18885 
  def __eq__(self, other):
18886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18887 
 
18888 
  def __ne__(self, other):
18889 
    return not (self == other)
18890 
 
18891 
class getAllAliveItems_result:
18892 
  """
18893 
  Attributes:
18894 
   - success
18895 
  """
18896 
 
18897 
  thrift_spec = (
18898 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18899 
  )
18900 
 
18901 
  def __init__(self, success=None,):
18902 
    self.success = success
18903 
 
18904 
  def read(self, iprot):
18905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18907 
      return
18908 
    iprot.readStructBegin()
18909 
    while True:
18910 
      (fname, ftype, fid) = iprot.readFieldBegin()
18911 
      if ftype == TType.STOP:
18912 
        break
18913 
      if fid == 0:
18914 
        if ftype == TType.LIST:
18915 
          self.success = []
9155 kshitij.so 18916 
          (_etype377, _size374) = iprot.readListBegin()
18917 
          for _i378 in xrange(_size374):
18918 
            _elem379 = Item()
18919 
            _elem379.read(iprot)
18920 
            self.success.append(_elem379)
6821 amar.kumar 18921 
          iprot.readListEnd()
18922 
        else:
18923 
          iprot.skip(ftype)
18924 
      else:
18925 
        iprot.skip(ftype)
18926 
      iprot.readFieldEnd()
18927 
    iprot.readStructEnd()
18928 
 
18929 
  def write(self, oprot):
18930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18932 
      return
18933 
    oprot.writeStructBegin('getAllAliveItems_result')
18934 
    if self.success is not None:
18935 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18936 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18937 
      for iter380 in self.success:
18938 
        iter380.write(oprot)
6821 amar.kumar 18939 
      oprot.writeListEnd()
18940 
      oprot.writeFieldEnd()
18941 
    oprot.writeFieldStop()
18942 
    oprot.writeStructEnd()
18943 
 
18944 
  def validate(self):
18945 
    return
18946 
 
18947 
 
18948 
  def __repr__(self):
18949 
    L = ['%s=%r' % (key, value)
18950 
      for key, value in self.__dict__.iteritems()]
18951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18952 
 
18953 
  def __eq__(self, other):
18954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18955 
 
18956 
  def __ne__(self, other):
18957 
    return not (self == other)
18958 
 
6805 anupam.sin 18959 
class getInsuranceAmount_args:
18960 
  """
18961 
  Attributes:
18962 
   - itemId
6921 anupam.sin 18963 
   - price
6805 anupam.sin 18964 
   - insurerId
18965 
   - quantity
18966 
  """
18967 
 
18968 
  thrift_spec = (
18969 
    None, # 0
18970 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 18971 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18972 
    (3, TType.I64, 'insurerId', None, None, ), # 3
18973 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 18974 
  )
18975 
 
6921 anupam.sin 18976 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 18977 
    self.itemId = itemId
6921 anupam.sin 18978 
    self.price = price
6805 anupam.sin 18979 
    self.insurerId = insurerId
18980 
    self.quantity = quantity
18981 
 
18982 
  def read(self, iprot):
18983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18985 
      return
18986 
    iprot.readStructBegin()
18987 
    while True:
18988 
      (fname, ftype, fid) = iprot.readFieldBegin()
18989 
      if ftype == TType.STOP:
18990 
        break
18991 
      if fid == 1:
18992 
        if ftype == TType.I64:
18993 
          self.itemId = iprot.readI64();
18994 
        else:
18995 
          iprot.skip(ftype)
18996 
      elif fid == 2:
6921 anupam.sin 18997 
        if ftype == TType.DOUBLE:
18998 
          self.price = iprot.readDouble();
18999 
        else:
19000 
          iprot.skip(ftype)
19001 
      elif fid == 3:
6805 anupam.sin 19002 
        if ftype == TType.I64:
19003 
          self.insurerId = iprot.readI64();
19004 
        else:
19005 
          iprot.skip(ftype)
6921 anupam.sin 19006 
      elif fid == 4:
6805 anupam.sin 19007 
        if ftype == TType.I64:
19008 
          self.quantity = iprot.readI64();
19009 
        else:
19010 
          iprot.skip(ftype)
19011 
      else:
19012 
        iprot.skip(ftype)
19013 
      iprot.readFieldEnd()
19014 
    iprot.readStructEnd()
19015 
 
19016 
  def write(self, oprot):
19017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19019 
      return
19020 
    oprot.writeStructBegin('getInsuranceAmount_args')
19021 
    if self.itemId is not None:
19022 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19023 
      oprot.writeI64(self.itemId)
19024 
      oprot.writeFieldEnd()
6921 anupam.sin 19025 
    if self.price is not None:
19026 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
19027 
      oprot.writeDouble(self.price)
19028 
      oprot.writeFieldEnd()
6805 anupam.sin 19029 
    if self.insurerId is not None:
6921 anupam.sin 19030 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 19031 
      oprot.writeI64(self.insurerId)
19032 
      oprot.writeFieldEnd()
19033 
    if self.quantity is not None:
6921 anupam.sin 19034 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 19035 
      oprot.writeI64(self.quantity)
19036 
      oprot.writeFieldEnd()
19037 
    oprot.writeFieldStop()
19038 
    oprot.writeStructEnd()
19039 
 
19040 
  def validate(self):
19041 
    return
19042 
 
19043 
 
19044 
  def __repr__(self):
19045 
    L = ['%s=%r' % (key, value)
19046 
      for key, value in self.__dict__.iteritems()]
19047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19048 
 
19049 
  def __eq__(self, other):
19050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19051 
 
19052 
  def __ne__(self, other):
19053 
    return not (self == other)
19054 
 
19055 
class getInsuranceAmount_result:
19056 
  """
19057 
  Attributes:
19058 
   - success
19059 
  """
19060 
 
19061 
  thrift_spec = (
19062 
    (0, TType.I64, 'success', None, None, ), # 0
19063 
  )
19064 
 
19065 
  def __init__(self, success=None,):
19066 
    self.success = success
19067 
 
19068 
  def read(self, iprot):
19069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19071 
      return
19072 
    iprot.readStructBegin()
19073 
    while True:
19074 
      (fname, ftype, fid) = iprot.readFieldBegin()
19075 
      if ftype == TType.STOP:
19076 
        break
19077 
      if fid == 0:
19078 
        if ftype == TType.I64:
19079 
          self.success = iprot.readI64();
19080 
        else:
19081 
          iprot.skip(ftype)
19082 
      else:
19083 
        iprot.skip(ftype)
19084 
      iprot.readFieldEnd()
19085 
    iprot.readStructEnd()
19086 
 
19087 
  def write(self, oprot):
19088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19090 
      return
19091 
    oprot.writeStructBegin('getInsuranceAmount_result')
19092 
    if self.success is not None:
19093 
      oprot.writeFieldBegin('success', TType.I64, 0)
19094 
      oprot.writeI64(self.success)
19095 
      oprot.writeFieldEnd()
19096 
    oprot.writeFieldStop()
19097 
    oprot.writeStructEnd()
19098 
 
19099 
  def validate(self):
19100 
    return
19101 
 
19102 
 
19103 
  def __repr__(self):
19104 
    L = ['%s=%r' % (key, value)
19105 
      for key, value in self.__dict__.iteritems()]
19106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19107 
 
19108 
  def __eq__(self, other):
19109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19110 
 
19111 
  def __ne__(self, other):
19112 
    return not (self == other)
19113 
 
19114 
class getInsurer_args:
19115 
  """
19116 
  Attributes:
19117 
   - insurerId
19118 
  """
19119 
 
19120 
  thrift_spec = (
19121 
    None, # 0
19122 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19123 
  )
19124 
 
19125 
  def __init__(self, insurerId=None,):
19126 
    self.insurerId = insurerId
19127 
 
19128 
  def read(self, iprot):
19129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19131 
      return
19132 
    iprot.readStructBegin()
19133 
    while True:
19134 
      (fname, ftype, fid) = iprot.readFieldBegin()
19135 
      if ftype == TType.STOP:
19136 
        break
19137 
      if fid == 1:
19138 
        if ftype == TType.I64:
19139 
          self.insurerId = iprot.readI64();
19140 
        else:
19141 
          iprot.skip(ftype)
19142 
      else:
19143 
        iprot.skip(ftype)
19144 
      iprot.readFieldEnd()
19145 
    iprot.readStructEnd()
19146 
 
19147 
  def write(self, oprot):
19148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19150 
      return
19151 
    oprot.writeStructBegin('getInsurer_args')
19152 
    if self.insurerId is not None:
19153 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19154 
      oprot.writeI64(self.insurerId)
19155 
      oprot.writeFieldEnd()
19156 
    oprot.writeFieldStop()
19157 
    oprot.writeStructEnd()
19158 
 
19159 
  def validate(self):
19160 
    return
19161 
 
19162 
 
19163 
  def __repr__(self):
19164 
    L = ['%s=%r' % (key, value)
19165 
      for key, value in self.__dict__.iteritems()]
19166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19167 
 
19168 
  def __eq__(self, other):
19169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19170 
 
19171 
  def __ne__(self, other):
19172 
    return not (self == other)
19173 
 
19174 
class getInsurer_result:
19175 
  """
19176 
  Attributes:
19177 
   - success
19178 
  """
19179 
 
19180 
  thrift_spec = (
19181 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
19182 
  )
19183 
 
19184 
  def __init__(self, success=None,):
19185 
    self.success = success
19186 
 
19187 
  def read(self, iprot):
19188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19190 
      return
19191 
    iprot.readStructBegin()
19192 
    while True:
19193 
      (fname, ftype, fid) = iprot.readFieldBegin()
19194 
      if ftype == TType.STOP:
19195 
        break
19196 
      if fid == 0:
19197 
        if ftype == TType.STRUCT:
19198 
          self.success = Insurer()
19199 
          self.success.read(iprot)
19200 
        else:
19201 
          iprot.skip(ftype)
19202 
      else:
19203 
        iprot.skip(ftype)
19204 
      iprot.readFieldEnd()
19205 
    iprot.readStructEnd()
19206 
 
19207 
  def write(self, oprot):
19208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19210 
      return
19211 
    oprot.writeStructBegin('getInsurer_result')
19212 
    if self.success is not None:
19213 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19214 
      self.success.write(oprot)
19215 
      oprot.writeFieldEnd()
19216 
    oprot.writeFieldStop()
19217 
    oprot.writeStructEnd()
19218 
 
19219 
  def validate(self):
19220 
    return
19221 
 
19222 
 
19223 
  def __repr__(self):
19224 
    L = ['%s=%r' % (key, value)
19225 
      for key, value in self.__dict__.iteritems()]
19226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19227 
 
19228 
  def __eq__(self, other):
19229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19230 
 
19231 
  def __ne__(self, other):
19232 
    return not (self == other)
6838 vikram.rag 19233 
 
19234 
class getAllInsurers_args:
19235 
 
19236 
  thrift_spec = (
19237 
  )
19238 
 
19239 
  def read(self, iprot):
19240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19242 
      return
19243 
    iprot.readStructBegin()
19244 
    while True:
19245 
      (fname, ftype, fid) = iprot.readFieldBegin()
19246 
      if ftype == TType.STOP:
19247 
        break
19248 
      else:
19249 
        iprot.skip(ftype)
19250 
      iprot.readFieldEnd()
19251 
    iprot.readStructEnd()
19252 
 
19253 
  def write(self, oprot):
19254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19256 
      return
19257 
    oprot.writeStructBegin('getAllInsurers_args')
19258 
    oprot.writeFieldStop()
19259 
    oprot.writeStructEnd()
19260 
 
19261 
  def validate(self):
19262 
    return
19263 
 
19264 
 
19265 
  def __repr__(self):
19266 
    L = ['%s=%r' % (key, value)
19267 
      for key, value in self.__dict__.iteritems()]
19268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19269 
 
19270 
  def __eq__(self, other):
19271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19272 
 
19273 
  def __ne__(self, other):
19274 
    return not (self == other)
19275 
 
19276 
class getAllInsurers_result:
19277 
  """
19278 
  Attributes:
19279 
   - success
19280 
  """
19281 
 
19282 
  thrift_spec = (
19283 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
19284 
  )
19285 
 
19286 
  def __init__(self, success=None,):
19287 
    self.success = success
19288 
 
19289 
  def read(self, iprot):
19290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19292 
      return
19293 
    iprot.readStructBegin()
19294 
    while True:
19295 
      (fname, ftype, fid) = iprot.readFieldBegin()
19296 
      if ftype == TType.STOP:
19297 
        break
19298 
      if fid == 0:
19299 
        if ftype == TType.LIST:
19300 
          self.success = []
9155 kshitij.so 19301 
          (_etype384, _size381) = iprot.readListBegin()
19302 
          for _i385 in xrange(_size381):
19303 
            _elem386 = Insurer()
19304 
            _elem386.read(iprot)
19305 
            self.success.append(_elem386)
6838 vikram.rag 19306 
          iprot.readListEnd()
19307 
        else:
19308 
          iprot.skip(ftype)
19309 
      else:
19310 
        iprot.skip(ftype)
19311 
      iprot.readFieldEnd()
19312 
    iprot.readStructEnd()
19313 
 
19314 
  def write(self, oprot):
19315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19317 
      return
19318 
    oprot.writeStructBegin('getAllInsurers_result')
19319 
    if self.success is not None:
19320 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19321 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19322 
      for iter387 in self.success:
19323 
        iter387.write(oprot)
6838 vikram.rag 19324 
      oprot.writeListEnd()
19325 
      oprot.writeFieldEnd()
19326 
    oprot.writeFieldStop()
19327 
    oprot.writeStructEnd()
19328 
 
19329 
  def validate(self):
19330 
    return
19331 
 
19332 
 
19333 
  def __repr__(self):
19334 
    L = ['%s=%r' % (key, value)
19335 
      for key, value in self.__dict__.iteritems()]
19336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19337 
 
19338 
  def __eq__(self, other):
19339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19340 
 
19341 
  def __ne__(self, other):
19342 
    return not (self == other)
6962 rajveer 19343 
 
19344 
class updateInsuranceDeclaredAmount_args:
19345 
  """
19346 
  Attributes:
19347 
   - insurerId
19348 
   - amount
19349 
  """
19350 
 
19351 
  thrift_spec = (
19352 
    None, # 0
19353 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19354 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
19355 
  )
19356 
 
19357 
  def __init__(self, insurerId=None, amount=None,):
19358 
    self.insurerId = insurerId
19359 
    self.amount = amount
19360 
 
19361 
  def read(self, iprot):
19362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19364 
      return
19365 
    iprot.readStructBegin()
19366 
    while True:
19367 
      (fname, ftype, fid) = iprot.readFieldBegin()
19368 
      if ftype == TType.STOP:
19369 
        break
19370 
      if fid == 1:
19371 
        if ftype == TType.I64:
19372 
          self.insurerId = iprot.readI64();
19373 
        else:
19374 
          iprot.skip(ftype)
19375 
      elif fid == 2:
19376 
        if ftype == TType.DOUBLE:
19377 
          self.amount = iprot.readDouble();
19378 
        else:
19379 
          iprot.skip(ftype)
19380 
      else:
19381 
        iprot.skip(ftype)
19382 
      iprot.readFieldEnd()
19383 
    iprot.readStructEnd()
19384 
 
19385 
  def write(self, oprot):
19386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19388 
      return
19389 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
19390 
    if self.insurerId is not None:
19391 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19392 
      oprot.writeI64(self.insurerId)
19393 
      oprot.writeFieldEnd()
19394 
    if self.amount is not None:
19395 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
19396 
      oprot.writeDouble(self.amount)
19397 
      oprot.writeFieldEnd()
19398 
    oprot.writeFieldStop()
19399 
    oprot.writeStructEnd()
19400 
 
19401 
  def validate(self):
19402 
    return
19403 
 
19404 
 
19405 
  def __repr__(self):
19406 
    L = ['%s=%r' % (key, value)
19407 
      for key, value in self.__dict__.iteritems()]
19408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19409 
 
19410 
  def __eq__(self, other):
19411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19412 
 
19413 
  def __ne__(self, other):
19414 
    return not (self == other)
19415 
 
19416 
class updateInsuranceDeclaredAmount_result:
19417 
 
19418 
  thrift_spec = (
19419 
  )
19420 
 
19421 
  def read(self, iprot):
19422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19424 
      return
19425 
    iprot.readStructBegin()
19426 
    while True:
19427 
      (fname, ftype, fid) = iprot.readFieldBegin()
19428 
      if ftype == TType.STOP:
19429 
        break
19430 
      else:
19431 
        iprot.skip(ftype)
19432 
      iprot.readFieldEnd()
19433 
    iprot.readStructEnd()
19434 
 
19435 
  def write(self, oprot):
19436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19438 
      return
19439 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
19440 
    oprot.writeFieldStop()
19441 
    oprot.writeStructEnd()
19442 
 
19443 
  def validate(self):
19444 
    return
19445 
 
19446 
 
19447 
  def __repr__(self):
19448 
    L = ['%s=%r' % (key, value)
19449 
      for key, value in self.__dict__.iteritems()]
19450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19451 
 
19452 
  def __eq__(self, other):
19453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19454 
 
19455 
  def __ne__(self, other):
19456 
    return not (self == other)
7190 amar.kumar 19457 
 
19458 
class getFreebieForItem_args:
19459 
  """
19460 
  Attributes:
19461 
   - itemId
19462 
  """
19463 
 
19464 
  thrift_spec = (
19465 
    None, # 0
19466 
    (1, TType.I64, 'itemId', None, None, ), # 1
19467 
  )
19468 
 
19469 
  def __init__(self, itemId=None,):
19470 
    self.itemId = itemId
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 
      if fid == 1:
19482 
        if ftype == TType.I64:
19483 
          self.itemId = iprot.readI64();
19484 
        else:
19485 
          iprot.skip(ftype)
19486 
      else:
19487 
        iprot.skip(ftype)
19488 
      iprot.readFieldEnd()
19489 
    iprot.readStructEnd()
19490 
 
19491 
  def write(self, oprot):
19492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19494 
      return
19495 
    oprot.writeStructBegin('getFreebieForItem_args')
19496 
    if self.itemId is not None:
19497 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19498 
      oprot.writeI64(self.itemId)
19499 
      oprot.writeFieldEnd()
19500 
    oprot.writeFieldStop()
19501 
    oprot.writeStructEnd()
19502 
 
19503 
  def validate(self):
19504 
    return
19505 
 
19506 
 
19507 
  def __repr__(self):
19508 
    L = ['%s=%r' % (key, value)
19509 
      for key, value in self.__dict__.iteritems()]
19510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19511 
 
19512 
  def __eq__(self, other):
19513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19514 
 
19515 
  def __ne__(self, other):
19516 
    return not (self == other)
19517 
 
19518 
class getFreebieForItem_result:
19519 
  """
19520 
  Attributes:
19521 
   - success
19522 
  """
19523 
 
19524 
  thrift_spec = (
19525 
    (0, TType.I64, 'success', None, None, ), # 0
19526 
  )
19527 
 
19528 
  def __init__(self, success=None,):
19529 
    self.success = success
19530 
 
19531 
  def read(self, iprot):
19532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19534 
      return
19535 
    iprot.readStructBegin()
19536 
    while True:
19537 
      (fname, ftype, fid) = iprot.readFieldBegin()
19538 
      if ftype == TType.STOP:
19539 
        break
19540 
      if fid == 0:
19541 
        if ftype == TType.I64:
19542 
          self.success = iprot.readI64();
19543 
        else:
19544 
          iprot.skip(ftype)
19545 
      else:
19546 
        iprot.skip(ftype)
19547 
      iprot.readFieldEnd()
19548 
    iprot.readStructEnd()
19549 
 
19550 
  def write(self, oprot):
19551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19553 
      return
19554 
    oprot.writeStructBegin('getFreebieForItem_result')
19555 
    if self.success is not None:
19556 
      oprot.writeFieldBegin('success', TType.I64, 0)
19557 
      oprot.writeI64(self.success)
19558 
      oprot.writeFieldEnd()
19559 
    oprot.writeFieldStop()
19560 
    oprot.writeStructEnd()
19561 
 
19562 
  def validate(self):
19563 
    return
19564 
 
19565 
 
19566 
  def __repr__(self):
19567 
    L = ['%s=%r' % (key, value)
19568 
      for key, value in self.__dict__.iteritems()]
19569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19570 
 
19571 
  def __eq__(self, other):
19572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19573 
 
19574 
  def __ne__(self, other):
19575 
    return not (self == other)
19576 
 
19577 
class addOrUpdateFreebieForItem_args:
19578 
  """
19579 
  Attributes:
19580 
   - freebieItem
19581 
  """
19582 
 
19583 
  thrift_spec = (
19584 
    None, # 0
19585 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
19586 
  )
19587 
 
19588 
  def __init__(self, freebieItem=None,):
19589 
    self.freebieItem = freebieItem
19590 
 
19591 
  def read(self, iprot):
19592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19594 
      return
19595 
    iprot.readStructBegin()
19596 
    while True:
19597 
      (fname, ftype, fid) = iprot.readFieldBegin()
19598 
      if ftype == TType.STOP:
19599 
        break
19600 
      if fid == 1:
19601 
        if ftype == TType.STRUCT:
19602 
          self.freebieItem = FreebieItem()
19603 
          self.freebieItem.read(iprot)
19604 
        else:
19605 
          iprot.skip(ftype)
19606 
      else:
19607 
        iprot.skip(ftype)
19608 
      iprot.readFieldEnd()
19609 
    iprot.readStructEnd()
19610 
 
19611 
  def write(self, oprot):
19612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19614 
      return
19615 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
19616 
    if self.freebieItem is not None:
19617 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
19618 
      self.freebieItem.write(oprot)
19619 
      oprot.writeFieldEnd()
19620 
    oprot.writeFieldStop()
19621 
    oprot.writeStructEnd()
19622 
 
19623 
  def validate(self):
19624 
    return
19625 
 
19626 
 
19627 
  def __repr__(self):
19628 
    L = ['%s=%r' % (key, value)
19629 
      for key, value in self.__dict__.iteritems()]
19630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19631 
 
19632 
  def __eq__(self, other):
19633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19634 
 
19635 
  def __ne__(self, other):
19636 
    return not (self == other)
19637 
 
19638 
class addOrUpdateFreebieForItem_result:
19639 
 
19640 
  thrift_spec = (
19641 
  )
19642 
 
19643 
  def read(self, iprot):
19644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19646 
      return
19647 
    iprot.readStructBegin()
19648 
    while True:
19649 
      (fname, ftype, fid) = iprot.readFieldBegin()
19650 
      if ftype == TType.STOP:
19651 
        break
19652 
      else:
19653 
        iprot.skip(ftype)
19654 
      iprot.readFieldEnd()
19655 
    iprot.readStructEnd()
19656 
 
19657 
  def write(self, oprot):
19658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19660 
      return
19661 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
19662 
    oprot.writeFieldStop()
19663 
    oprot.writeStructEnd()
19664 
 
19665 
  def validate(self):
19666 
    return
19667 
 
19668 
 
19669 
  def __repr__(self):
19670 
    L = ['%s=%r' % (key, value)
19671 
      for key, value in self.__dict__.iteritems()]
19672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19673 
 
19674 
  def __eq__(self, other):
19675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19676 
 
19677 
  def __ne__(self, other):
19678 
    return not (self == other)
7256 rajveer 19679 
 
7272 amit.gupta 19680 
class addOrUpdateBrandInfo_args:
19681 
  """
19682 
  Attributes:
19683 
   - brandInfo
19684 
  """
19685 
 
19686 
  thrift_spec = (
19687 
    None, # 0
19688 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
19689 
  )
19690 
 
19691 
  def __init__(self, brandInfo=None,):
19692 
    self.brandInfo = brandInfo
19693 
 
19694 
  def read(self, iprot):
19695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19697 
      return
19698 
    iprot.readStructBegin()
19699 
    while True:
19700 
      (fname, ftype, fid) = iprot.readFieldBegin()
19701 
      if ftype == TType.STOP:
19702 
        break
19703 
      if fid == 1:
19704 
        if ftype == TType.STRUCT:
19705 
          self.brandInfo = BrandInfo()
19706 
          self.brandInfo.read(iprot)
19707 
        else:
19708 
          iprot.skip(ftype)
19709 
      else:
19710 
        iprot.skip(ftype)
19711 
      iprot.readFieldEnd()
19712 
    iprot.readStructEnd()
19713 
 
19714 
  def write(self, oprot):
19715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19717 
      return
19718 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
19719 
    if self.brandInfo is not None:
19720 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
19721 
      self.brandInfo.write(oprot)
19722 
      oprot.writeFieldEnd()
19723 
    oprot.writeFieldStop()
19724 
    oprot.writeStructEnd()
19725 
 
19726 
  def validate(self):
19727 
    return
19728 
 
19729 
 
19730 
  def __repr__(self):
19731 
    L = ['%s=%r' % (key, value)
19732 
      for key, value in self.__dict__.iteritems()]
19733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19734 
 
19735 
  def __eq__(self, other):
19736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19737 
 
19738 
  def __ne__(self, other):
19739 
    return not (self == other)
19740 
 
19741 
class addOrUpdateBrandInfo_result:
19742 
 
19743 
  thrift_spec = (
19744 
  )
19745 
 
19746 
  def read(self, iprot):
19747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19749 
      return
19750 
    iprot.readStructBegin()
19751 
    while True:
19752 
      (fname, ftype, fid) = iprot.readFieldBegin()
19753 
      if ftype == TType.STOP:
19754 
        break
19755 
      else:
19756 
        iprot.skip(ftype)
19757 
      iprot.readFieldEnd()
19758 
    iprot.readStructEnd()
19759 
 
19760 
  def write(self, oprot):
19761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19763 
      return
19764 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
19765 
    oprot.writeFieldStop()
19766 
    oprot.writeStructEnd()
19767 
 
19768 
  def validate(self):
19769 
    return
19770 
 
19771 
 
19772 
  def __repr__(self):
19773 
    L = ['%s=%r' % (key, value)
19774 
      for key, value in self.__dict__.iteritems()]
19775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19776 
 
19777 
  def __eq__(self, other):
19778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19779 
 
19780 
  def __ne__(self, other):
19781 
    return not (self == other)
19782 
 
19783 
class getBrandInfo_args:
19784 
 
19785 
  thrift_spec = (
19786 
  )
19787 
 
19788 
  def read(self, iprot):
19789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19791 
      return
19792 
    iprot.readStructBegin()
19793 
    while True:
19794 
      (fname, ftype, fid) = iprot.readFieldBegin()
19795 
      if ftype == TType.STOP:
19796 
        break
19797 
      else:
19798 
        iprot.skip(ftype)
19799 
      iprot.readFieldEnd()
19800 
    iprot.readStructEnd()
19801 
 
19802 
  def write(self, oprot):
19803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19805 
      return
19806 
    oprot.writeStructBegin('getBrandInfo_args')
19807 
    oprot.writeFieldStop()
19808 
    oprot.writeStructEnd()
19809 
 
19810 
  def validate(self):
19811 
    return
19812 
 
19813 
 
19814 
  def __repr__(self):
19815 
    L = ['%s=%r' % (key, value)
19816 
      for key, value in self.__dict__.iteritems()]
19817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19818 
 
19819 
  def __eq__(self, other):
19820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19821 
 
19822 
  def __ne__(self, other):
19823 
    return not (self == other)
19824 
 
19825 
class getBrandInfo_result:
19826 
  """
19827 
  Attributes:
19828 
   - success
19829 
  """
19830 
 
19831 
  thrift_spec = (
19832 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
19833 
  )
19834 
 
19835 
  def __init__(self, success=None,):
19836 
    self.success = success
19837 
 
19838 
  def read(self, iprot):
19839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19841 
      return
19842 
    iprot.readStructBegin()
19843 
    while True:
19844 
      (fname, ftype, fid) = iprot.readFieldBegin()
19845 
      if ftype == TType.STOP:
19846 
        break
19847 
      if fid == 0:
19848 
        if ftype == TType.MAP:
19849 
          self.success = {}
9155 kshitij.so 19850 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
19851 
          for _i392 in xrange(_size388):
19852 
            _key393 = iprot.readString();
19853 
            _val394 = BrandInfo()
19854 
            _val394.read(iprot)
19855 
            self.success[_key393] = _val394
7272 amit.gupta 19856 
          iprot.readMapEnd()
19857 
        else:
19858 
          iprot.skip(ftype)
19859 
      else:
19860 
        iprot.skip(ftype)
19861 
      iprot.readFieldEnd()
19862 
    iprot.readStructEnd()
19863 
 
19864 
  def write(self, oprot):
19865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19867 
      return
19868 
    oprot.writeStructBegin('getBrandInfo_result')
19869 
    if self.success is not None:
19870 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19871 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 19872 
      for kiter395,viter396 in self.success.items():
19873 
        oprot.writeString(kiter395)
19874 
        viter396.write(oprot)
7272 amit.gupta 19875 
      oprot.writeMapEnd()
19876 
      oprot.writeFieldEnd()
19877 
    oprot.writeFieldStop()
19878 
    oprot.writeStructEnd()
19879 
 
19880 
  def validate(self):
19881 
    return
19882 
 
19883 
 
19884 
  def __repr__(self):
19885 
    L = ['%s=%r' % (key, value)
19886 
      for key, value in self.__dict__.iteritems()]
19887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19888 
 
19889 
  def __eq__(self, other):
19890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19891 
 
19892 
  def __ne__(self, other):
19893 
    return not (self == other)
19894 
 
7256 rajveer 19895 
class getStorePricing_args:
19896 
  """
19897 
  Attributes:
19898 
   - itemId
19899 
  """
19900 
 
19901 
  thrift_spec = (
19902 
    None, # 0
19903 
    (1, TType.I64, 'itemId', None, None, ), # 1
19904 
  )
19905 
 
19906 
  def __init__(self, itemId=None,):
19907 
    self.itemId = itemId
19908 
 
19909 
  def read(self, iprot):
19910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19912 
      return
19913 
    iprot.readStructBegin()
19914 
    while True:
19915 
      (fname, ftype, fid) = iprot.readFieldBegin()
19916 
      if ftype == TType.STOP:
19917 
        break
19918 
      if fid == 1:
19919 
        if ftype == TType.I64:
19920 
          self.itemId = iprot.readI64();
19921 
        else:
19922 
          iprot.skip(ftype)
19923 
      else:
19924 
        iprot.skip(ftype)
19925 
      iprot.readFieldEnd()
19926 
    iprot.readStructEnd()
19927 
 
19928 
  def write(self, oprot):
19929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19931 
      return
19932 
    oprot.writeStructBegin('getStorePricing_args')
19933 
    if self.itemId is not None:
19934 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19935 
      oprot.writeI64(self.itemId)
19936 
      oprot.writeFieldEnd()
19937 
    oprot.writeFieldStop()
19938 
    oprot.writeStructEnd()
19939 
 
19940 
  def validate(self):
19941 
    return
19942 
 
19943 
 
19944 
  def __repr__(self):
19945 
    L = ['%s=%r' % (key, value)
19946 
      for key, value in self.__dict__.iteritems()]
19947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19948 
 
19949 
  def __eq__(self, other):
19950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19951 
 
19952 
  def __ne__(self, other):
19953 
    return not (self == other)
19954 
 
19955 
class getStorePricing_result:
19956 
  """
19957 
  Attributes:
19958 
   - success
19959 
  """
19960 
 
19961 
  thrift_spec = (
19962 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
19963 
  )
19964 
 
19965 
  def __init__(self, success=None,):
19966 
    self.success = success
19967 
 
19968 
  def read(self, iprot):
19969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19971 
      return
19972 
    iprot.readStructBegin()
19973 
    while True:
19974 
      (fname, ftype, fid) = iprot.readFieldBegin()
19975 
      if ftype == TType.STOP:
19976 
        break
19977 
      if fid == 0:
19978 
        if ftype == TType.STRUCT:
19979 
          self.success = StorePricing()
19980 
          self.success.read(iprot)
19981 
        else:
19982 
          iprot.skip(ftype)
19983 
      else:
19984 
        iprot.skip(ftype)
19985 
      iprot.readFieldEnd()
19986 
    iprot.readStructEnd()
19987 
 
19988 
  def write(self, oprot):
19989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19991 
      return
19992 
    oprot.writeStructBegin('getStorePricing_result')
19993 
    if self.success is not None:
19994 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19995 
      self.success.write(oprot)
19996 
      oprot.writeFieldEnd()
19997 
    oprot.writeFieldStop()
19998 
    oprot.writeStructEnd()
19999 
 
20000 
  def validate(self):
20001 
    return
20002 
 
20003 
 
20004 
  def __repr__(self):
20005 
    L = ['%s=%r' % (key, value)
20006 
      for key, value in self.__dict__.iteritems()]
20007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20008 
 
20009 
  def __eq__(self, other):
20010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20011 
 
20012 
  def __ne__(self, other):
20013 
    return not (self == other)
7265 rajveer 20014 
 
7306 rajveer 20015 
class getStorePricings_args:
20016 
  """
20017 
  Attributes:
20018 
   - itemIds
20019 
  """
20020 
 
20021 
  thrift_spec = (
20022 
    None, # 0
20023 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20024 
  )
20025 
 
20026 
  def __init__(self, itemIds=None,):
20027 
    self.itemIds = itemIds
20028 
 
20029 
  def read(self, iprot):
20030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20032 
      return
20033 
    iprot.readStructBegin()
20034 
    while True:
20035 
      (fname, ftype, fid) = iprot.readFieldBegin()
20036 
      if ftype == TType.STOP:
20037 
        break
20038 
      if fid == 1:
20039 
        if ftype == TType.LIST:
20040 
          self.itemIds = []
9155 kshitij.so 20041 
          (_etype400, _size397) = iprot.readListBegin()
20042 
          for _i401 in xrange(_size397):
20043 
            _elem402 = iprot.readI64();
20044 
            self.itemIds.append(_elem402)
7306 rajveer 20045 
          iprot.readListEnd()
20046 
        else:
20047 
          iprot.skip(ftype)
20048 
      else:
20049 
        iprot.skip(ftype)
20050 
      iprot.readFieldEnd()
20051 
    iprot.readStructEnd()
20052 
 
20053 
  def write(self, oprot):
20054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20056 
      return
20057 
    oprot.writeStructBegin('getStorePricings_args')
20058 
    if self.itemIds is not None:
20059 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20060 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 20061 
      for iter403 in self.itemIds:
20062 
        oprot.writeI64(iter403)
7306 rajveer 20063 
      oprot.writeListEnd()
20064 
      oprot.writeFieldEnd()
20065 
    oprot.writeFieldStop()
20066 
    oprot.writeStructEnd()
20067 
 
20068 
  def validate(self):
20069 
    return
20070 
 
20071 
 
20072 
  def __repr__(self):
20073 
    L = ['%s=%r' % (key, value)
20074 
      for key, value in self.__dict__.iteritems()]
20075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20076 
 
20077 
  def __eq__(self, other):
20078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20079 
 
20080 
  def __ne__(self, other):
20081 
    return not (self == other)
20082 
 
20083 
class getStorePricings_result:
20084 
  """
20085 
  Attributes:
20086 
   - success
20087 
  """
20088 
 
20089 
  thrift_spec = (
20090 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
20091 
  )
20092 
 
20093 
  def __init__(self, success=None,):
20094 
    self.success = success
20095 
 
20096 
  def read(self, iprot):
20097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20099 
      return
20100 
    iprot.readStructBegin()
20101 
    while True:
20102 
      (fname, ftype, fid) = iprot.readFieldBegin()
20103 
      if ftype == TType.STOP:
20104 
        break
20105 
      if fid == 0:
20106 
        if ftype == TType.LIST:
20107 
          self.success = []
9155 kshitij.so 20108 
          (_etype407, _size404) = iprot.readListBegin()
20109 
          for _i408 in xrange(_size404):
20110 
            _elem409 = StorePricing()
20111 
            _elem409.read(iprot)
20112 
            self.success.append(_elem409)
7306 rajveer 20113 
          iprot.readListEnd()
20114 
        else:
20115 
          iprot.skip(ftype)
20116 
      else:
20117 
        iprot.skip(ftype)
20118 
      iprot.readFieldEnd()
20119 
    iprot.readStructEnd()
20120 
 
20121 
  def write(self, oprot):
20122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20124 
      return
20125 
    oprot.writeStructBegin('getStorePricings_result')
20126 
    if self.success is not None:
20127 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20128 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20129 
      for iter410 in self.success:
20130 
        iter410.write(oprot)
7306 rajveer 20131 
      oprot.writeListEnd()
20132 
      oprot.writeFieldEnd()
20133 
    oprot.writeFieldStop()
20134 
    oprot.writeStructEnd()
20135 
 
20136 
  def validate(self):
20137 
    return
20138 
 
20139 
 
20140 
  def __repr__(self):
20141 
    L = ['%s=%r' % (key, value)
20142 
      for key, value in self.__dict__.iteritems()]
20143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20144 
 
20145 
  def __eq__(self, other):
20146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20147 
 
20148 
  def __ne__(self, other):
20149 
    return not (self == other)
20150 
 
7265 rajveer 20151 
class updateStorePricing_args:
20152 
  """
20153 
  Attributes:
20154 
   - sp
7382 rajveer 20155 
   - allColors
7265 rajveer 20156 
  """
20157 
 
20158 
  thrift_spec = (
20159 
    None, # 0
20160 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 20161 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 20162 
  )
20163 
 
7382 rajveer 20164 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 20165 
    self.sp = sp
7382 rajveer 20166 
    self.allColors = allColors
7265 rajveer 20167 
 
20168 
  def read(self, iprot):
20169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20171 
      return
20172 
    iprot.readStructBegin()
20173 
    while True:
20174 
      (fname, ftype, fid) = iprot.readFieldBegin()
20175 
      if ftype == TType.STOP:
20176 
        break
20177 
      if fid == 1:
20178 
        if ftype == TType.STRUCT:
20179 
          self.sp = StorePricing()
20180 
          self.sp.read(iprot)
20181 
        else:
20182 
          iprot.skip(ftype)
7382 rajveer 20183 
      elif fid == 2:
20184 
        if ftype == TType.BOOL:
20185 
          self.allColors = iprot.readBool();
20186 
        else:
20187 
          iprot.skip(ftype)
7265 rajveer 20188 
      else:
20189 
        iprot.skip(ftype)
20190 
      iprot.readFieldEnd()
20191 
    iprot.readStructEnd()
20192 
 
20193 
  def write(self, oprot):
20194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20196 
      return
20197 
    oprot.writeStructBegin('updateStorePricing_args')
20198 
    if self.sp is not None:
20199 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
20200 
      self.sp.write(oprot)
20201 
      oprot.writeFieldEnd()
7382 rajveer 20202 
    if self.allColors is not None:
20203 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
20204 
      oprot.writeBool(self.allColors)
20205 
      oprot.writeFieldEnd()
7265 rajveer 20206 
    oprot.writeFieldStop()
20207 
    oprot.writeStructEnd()
20208 
 
20209 
  def validate(self):
20210 
    return
20211 
 
20212 
 
20213 
  def __repr__(self):
20214 
    L = ['%s=%r' % (key, value)
20215 
      for key, value in self.__dict__.iteritems()]
20216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20217 
 
20218 
  def __eq__(self, other):
20219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20220 
 
20221 
  def __ne__(self, other):
20222 
    return not (self == other)
20223 
 
20224 
class updateStorePricing_result:
20225 
 
20226 
  thrift_spec = (
20227 
  )
20228 
 
20229 
  def read(self, iprot):
20230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20232 
      return
20233 
    iprot.readStructBegin()
20234 
    while True:
20235 
      (fname, ftype, fid) = iprot.readFieldBegin()
20236 
      if ftype == TType.STOP:
20237 
        break
20238 
      else:
20239 
        iprot.skip(ftype)
20240 
      iprot.readFieldEnd()
20241 
    iprot.readStructEnd()
20242 
 
20243 
  def write(self, oprot):
20244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20246 
      return
20247 
    oprot.writeStructBegin('updateStorePricing_result')
20248 
    oprot.writeFieldStop()
20249 
    oprot.writeStructEnd()
20250 
 
20251 
  def validate(self):
20252 
    return
20253 
 
20254 
 
20255 
  def __repr__(self):
20256 
    L = ['%s=%r' % (key, value)
20257 
      for key, value in self.__dict__.iteritems()]
20258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20259 
 
20260 
  def __eq__(self, other):
20261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20262 
 
20263 
  def __ne__(self, other):
20264 
    return not (self == other)
7281 kshitij.so 20265 
 
20266 
class getAllAmazonListedItems_args:
20267 
 
20268 
  thrift_spec = (
20269 
  )
20270 
 
20271 
  def read(self, iprot):
20272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20274 
      return
20275 
    iprot.readStructBegin()
20276 
    while True:
20277 
      (fname, ftype, fid) = iprot.readFieldBegin()
20278 
      if ftype == TType.STOP:
20279 
        break
20280 
      else:
20281 
        iprot.skip(ftype)
20282 
      iprot.readFieldEnd()
20283 
    iprot.readStructEnd()
20284 
 
20285 
  def write(self, oprot):
20286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20288 
      return
20289 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
20290 
    oprot.writeFieldStop()
20291 
    oprot.writeStructEnd()
20292 
 
20293 
  def validate(self):
20294 
    return
20295 
 
20296 
 
20297 
  def __repr__(self):
20298 
    L = ['%s=%r' % (key, value)
20299 
      for key, value in self.__dict__.iteritems()]
20300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20301 
 
20302 
  def __eq__(self, other):
20303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20304 
 
20305 
  def __ne__(self, other):
20306 
    return not (self == other)
20307 
 
20308 
class getAllAmazonListedItems_result:
20309 
  """
20310 
  Attributes:
20311 
   - success
20312 
  """
20313 
 
20314 
  thrift_spec = (
20315 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20316 
  )
20317 
 
20318 
  def __init__(self, success=None,):
20319 
    self.success = success
20320 
 
20321 
  def read(self, iprot):
20322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20324 
      return
20325 
    iprot.readStructBegin()
20326 
    while True:
20327 
      (fname, ftype, fid) = iprot.readFieldBegin()
20328 
      if ftype == TType.STOP:
20329 
        break
20330 
      if fid == 0:
20331 
        if ftype == TType.LIST:
20332 
          self.success = []
9155 kshitij.so 20333 
          (_etype414, _size411) = iprot.readListBegin()
20334 
          for _i415 in xrange(_size411):
20335 
            _elem416 = Amazonlisted()
20336 
            _elem416.read(iprot)
20337 
            self.success.append(_elem416)
7281 kshitij.so 20338 
          iprot.readListEnd()
20339 
        else:
20340 
          iprot.skip(ftype)
20341 
      else:
20342 
        iprot.skip(ftype)
20343 
      iprot.readFieldEnd()
20344 
    iprot.readStructEnd()
20345 
 
20346 
  def write(self, oprot):
20347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20349 
      return
20350 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
20351 
    if self.success is not None:
20352 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20353 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20354 
      for iter417 in self.success:
20355 
        iter417.write(oprot)
7281 kshitij.so 20356 
      oprot.writeListEnd()
20357 
      oprot.writeFieldEnd()
20358 
    oprot.writeFieldStop()
20359 
    oprot.writeStructEnd()
20360 
 
20361 
  def validate(self):
20362 
    return
20363 
 
20364 
 
20365 
  def __repr__(self):
20366 
    L = ['%s=%r' % (key, value)
20367 
      for key, value in self.__dict__.iteritems()]
20368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20369 
 
20370 
  def __eq__(self, other):
20371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20372 
 
20373 
  def __ne__(self, other):
20374 
    return not (self == other)
20375 
 
8619 kshitij.so 20376 
class searchAmazonItems_args:
20377 
  """
20378 
  Attributes:
20379 
   - searchTerm
20380 
   - offset
20381 
   - limit
20382 
  """
20383 
 
20384 
  thrift_spec = (
20385 
    None, # 0
20386 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20387 
    (2, TType.I64, 'offset', None, None, ), # 2
20388 
    (3, TType.I64, 'limit', None, None, ), # 3
20389 
  )
20390 
 
20391 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
20392 
    self.searchTerm = searchTerm
20393 
    self.offset = offset
20394 
    self.limit = limit
20395 
 
20396 
  def read(self, iprot):
20397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20399 
      return
20400 
    iprot.readStructBegin()
20401 
    while True:
20402 
      (fname, ftype, fid) = iprot.readFieldBegin()
20403 
      if ftype == TType.STOP:
20404 
        break
20405 
      if fid == 1:
20406 
        if ftype == TType.LIST:
20407 
          self.searchTerm = []
9155 kshitij.so 20408 
          (_etype421, _size418) = iprot.readListBegin()
20409 
          for _i422 in xrange(_size418):
20410 
            _elem423 = iprot.readString();
20411 
            self.searchTerm.append(_elem423)
8619 kshitij.so 20412 
          iprot.readListEnd()
20413 
        else:
20414 
          iprot.skip(ftype)
20415 
      elif fid == 2:
20416 
        if ftype == TType.I64:
20417 
          self.offset = iprot.readI64();
20418 
        else:
20419 
          iprot.skip(ftype)
20420 
      elif fid == 3:
20421 
        if ftype == TType.I64:
20422 
          self.limit = iprot.readI64();
20423 
        else:
20424 
          iprot.skip(ftype)
20425 
      else:
20426 
        iprot.skip(ftype)
20427 
      iprot.readFieldEnd()
20428 
    iprot.readStructEnd()
20429 
 
20430 
  def write(self, oprot):
20431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20433 
      return
20434 
    oprot.writeStructBegin('searchAmazonItems_args')
20435 
    if self.searchTerm is not None:
20436 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20437 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20438 
      for iter424 in self.searchTerm:
20439 
        oprot.writeString(iter424)
8619 kshitij.so 20440 
      oprot.writeListEnd()
20441 
      oprot.writeFieldEnd()
20442 
    if self.offset is not None:
20443 
      oprot.writeFieldBegin('offset', TType.I64, 2)
20444 
      oprot.writeI64(self.offset)
20445 
      oprot.writeFieldEnd()
20446 
    if self.limit is not None:
20447 
      oprot.writeFieldBegin('limit', TType.I64, 3)
20448 
      oprot.writeI64(self.limit)
20449 
      oprot.writeFieldEnd()
20450 
    oprot.writeFieldStop()
20451 
    oprot.writeStructEnd()
20452 
 
20453 
  def validate(self):
20454 
    return
20455 
 
20456 
 
20457 
  def __repr__(self):
20458 
    L = ['%s=%r' % (key, value)
20459 
      for key, value in self.__dict__.iteritems()]
20460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20461 
 
20462 
  def __eq__(self, other):
20463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20464 
 
20465 
  def __ne__(self, other):
20466 
    return not (self == other)
20467 
 
20468 
class searchAmazonItems_result:
20469 
  """
20470 
  Attributes:
20471 
   - success
20472 
  """
20473 
 
20474 
  thrift_spec = (
20475 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20476 
  )
20477 
 
20478 
  def __init__(self, success=None,):
20479 
    self.success = success
20480 
 
20481 
  def read(self, iprot):
20482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20484 
      return
20485 
    iprot.readStructBegin()
20486 
    while True:
20487 
      (fname, ftype, fid) = iprot.readFieldBegin()
20488 
      if ftype == TType.STOP:
20489 
        break
20490 
      if fid == 0:
20491 
        if ftype == TType.LIST:
20492 
          self.success = []
9155 kshitij.so 20493 
          (_etype428, _size425) = iprot.readListBegin()
20494 
          for _i429 in xrange(_size425):
20495 
            _elem430 = Amazonlisted()
20496 
            _elem430.read(iprot)
20497 
            self.success.append(_elem430)
8619 kshitij.so 20498 
          iprot.readListEnd()
20499 
        else:
20500 
          iprot.skip(ftype)
20501 
      else:
20502 
        iprot.skip(ftype)
20503 
      iprot.readFieldEnd()
20504 
    iprot.readStructEnd()
20505 
 
20506 
  def write(self, oprot):
20507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20509 
      return
20510 
    oprot.writeStructBegin('searchAmazonItems_result')
20511 
    if self.success is not None:
20512 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20513 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20514 
      for iter431 in self.success:
20515 
        iter431.write(oprot)
8619 kshitij.so 20516 
      oprot.writeListEnd()
20517 
      oprot.writeFieldEnd()
20518 
    oprot.writeFieldStop()
20519 
    oprot.writeStructEnd()
20520 
 
20521 
  def validate(self):
20522 
    return
20523 
 
20524 
 
20525 
  def __repr__(self):
20526 
    L = ['%s=%r' % (key, value)
20527 
      for key, value in self.__dict__.iteritems()]
20528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20529 
 
20530 
  def __eq__(self, other):
20531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20532 
 
20533 
  def __ne__(self, other):
20534 
    return not (self == other)
20535 
 
20536 
class getAmazonSearchResultCount_args:
20537 
  """
20538 
  Attributes:
20539 
   - searchTerm
20540 
  """
20541 
 
20542 
  thrift_spec = (
20543 
    None, # 0
20544 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20545 
  )
20546 
 
20547 
  def __init__(self, searchTerm=None,):
20548 
    self.searchTerm = searchTerm
20549 
 
20550 
  def read(self, iprot):
20551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20553 
      return
20554 
    iprot.readStructBegin()
20555 
    while True:
20556 
      (fname, ftype, fid) = iprot.readFieldBegin()
20557 
      if ftype == TType.STOP:
20558 
        break
20559 
      if fid == 1:
20560 
        if ftype == TType.LIST:
20561 
          self.searchTerm = []
9155 kshitij.so 20562 
          (_etype435, _size432) = iprot.readListBegin()
20563 
          for _i436 in xrange(_size432):
20564 
            _elem437 = iprot.readString();
20565 
            self.searchTerm.append(_elem437)
8619 kshitij.so 20566 
          iprot.readListEnd()
20567 
        else:
20568 
          iprot.skip(ftype)
20569 
      else:
20570 
        iprot.skip(ftype)
20571 
      iprot.readFieldEnd()
20572 
    iprot.readStructEnd()
20573 
 
20574 
  def write(self, oprot):
20575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20577 
      return
20578 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
20579 
    if self.searchTerm is not None:
20580 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20581 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20582 
      for iter438 in self.searchTerm:
20583 
        oprot.writeString(iter438)
8619 kshitij.so 20584 
      oprot.writeListEnd()
20585 
      oprot.writeFieldEnd()
20586 
    oprot.writeFieldStop()
20587 
    oprot.writeStructEnd()
20588 
 
20589 
  def validate(self):
20590 
    return
20591 
 
20592 
 
20593 
  def __repr__(self):
20594 
    L = ['%s=%r' % (key, value)
20595 
      for key, value in self.__dict__.iteritems()]
20596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20597 
 
20598 
  def __eq__(self, other):
20599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20600 
 
20601 
  def __ne__(self, other):
20602 
    return not (self == other)
20603 
 
20604 
class getAmazonSearchResultCount_result:
20605 
  """
20606 
  Attributes:
20607 
   - success
20608 
  """
20609 
 
20610 
  thrift_spec = (
20611 
    (0, TType.I64, 'success', None, None, ), # 0
20612 
  )
20613 
 
20614 
  def __init__(self, success=None,):
20615 
    self.success = success
20616 
 
20617 
  def read(self, iprot):
20618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20620 
      return
20621 
    iprot.readStructBegin()
20622 
    while True:
20623 
      (fname, ftype, fid) = iprot.readFieldBegin()
20624 
      if ftype == TType.STOP:
20625 
        break
20626 
      if fid == 0:
20627 
        if ftype == TType.I64:
20628 
          self.success = iprot.readI64();
20629 
        else:
20630 
          iprot.skip(ftype)
20631 
      else:
20632 
        iprot.skip(ftype)
20633 
      iprot.readFieldEnd()
20634 
    iprot.readStructEnd()
20635 
 
20636 
  def write(self, oprot):
20637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20639 
      return
20640 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
20641 
    if self.success is not None:
20642 
      oprot.writeFieldBegin('success', TType.I64, 0)
20643 
      oprot.writeI64(self.success)
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)
20662 
 
20663 
class getCountForAmazonlistedItems_args:
20664 
 
20665 
  thrift_spec = (
20666 
  )
20667 
 
20668 
  def read(self, iprot):
20669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20671 
      return
20672 
    iprot.readStructBegin()
20673 
    while True:
20674 
      (fname, ftype, fid) = iprot.readFieldBegin()
20675 
      if ftype == TType.STOP:
20676 
        break
20677 
      else:
20678 
        iprot.skip(ftype)
20679 
      iprot.readFieldEnd()
20680 
    iprot.readStructEnd()
20681 
 
20682 
  def write(self, oprot):
20683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20685 
      return
20686 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
20687 
    oprot.writeFieldStop()
20688 
    oprot.writeStructEnd()
20689 
 
20690 
  def validate(self):
20691 
    return
20692 
 
20693 
 
20694 
  def __repr__(self):
20695 
    L = ['%s=%r' % (key, value)
20696 
      for key, value in self.__dict__.iteritems()]
20697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20698 
 
20699 
  def __eq__(self, other):
20700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20701 
 
20702 
  def __ne__(self, other):
20703 
    return not (self == other)
20704 
 
20705 
class getCountForAmazonlistedItems_result:
20706 
  """
20707 
  Attributes:
20708 
   - success
20709 
  """
20710 
 
20711 
  thrift_spec = (
20712 
    (0, TType.I64, 'success', None, None, ), # 0
20713 
  )
20714 
 
20715 
  def __init__(self, success=None,):
20716 
    self.success = success
20717 
 
20718 
  def read(self, iprot):
20719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20721 
      return
20722 
    iprot.readStructBegin()
20723 
    while True:
20724 
      (fname, ftype, fid) = iprot.readFieldBegin()
20725 
      if ftype == TType.STOP:
20726 
        break
20727 
      if fid == 0:
20728 
        if ftype == TType.I64:
20729 
          self.success = iprot.readI64();
20730 
        else:
20731 
          iprot.skip(ftype)
20732 
      else:
20733 
        iprot.skip(ftype)
20734 
      iprot.readFieldEnd()
20735 
    iprot.readStructEnd()
20736 
 
20737 
  def write(self, oprot):
20738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20740 
      return
20741 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
20742 
    if self.success is not None:
20743 
      oprot.writeFieldBegin('success', TType.I64, 0)
20744 
      oprot.writeI64(self.success)
20745 
      oprot.writeFieldEnd()
20746 
    oprot.writeFieldStop()
20747 
    oprot.writeStructEnd()
20748 
 
20749 
  def validate(self):
20750 
    return
20751 
 
20752 
 
20753 
  def __repr__(self):
20754 
    L = ['%s=%r' % (key, value)
20755 
      for key, value in self.__dict__.iteritems()]
20756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20757 
 
20758 
  def __eq__(self, other):
20759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20760 
 
20761 
  def __ne__(self, other):
20762 
    return not (self == other)
20763 
 
7281 kshitij.so 20764 
class getAmazonItemDetails_args:
20765 
  """
20766 
  Attributes:
20767 
   - itemId
20768 
  """
20769 
 
20770 
  thrift_spec = (
20771 
    None, # 0
20772 
    (1, TType.I64, 'itemId', None, None, ), # 1
20773 
  )
20774 
 
20775 
  def __init__(self, itemId=None,):
20776 
    self.itemId = itemId
20777 
 
20778 
  def read(self, iprot):
20779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20781 
      return
20782 
    iprot.readStructBegin()
20783 
    while True:
20784 
      (fname, ftype, fid) = iprot.readFieldBegin()
20785 
      if ftype == TType.STOP:
20786 
        break
20787 
      if fid == 1:
20788 
        if ftype == TType.I64:
20789 
          self.itemId = iprot.readI64();
20790 
        else:
20791 
          iprot.skip(ftype)
20792 
      else:
20793 
        iprot.skip(ftype)
20794 
      iprot.readFieldEnd()
20795 
    iprot.readStructEnd()
20796 
 
20797 
  def write(self, oprot):
20798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20800 
      return
20801 
    oprot.writeStructBegin('getAmazonItemDetails_args')
20802 
    if self.itemId is not None:
20803 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20804 
      oprot.writeI64(self.itemId)
20805 
      oprot.writeFieldEnd()
20806 
    oprot.writeFieldStop()
20807 
    oprot.writeStructEnd()
20808 
 
20809 
  def validate(self):
20810 
    return
20811 
 
20812 
 
20813 
  def __repr__(self):
20814 
    L = ['%s=%r' % (key, value)
20815 
      for key, value in self.__dict__.iteritems()]
20816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20817 
 
20818 
  def __eq__(self, other):
20819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20820 
 
20821 
  def __ne__(self, other):
20822 
    return not (self == other)
20823 
 
20824 
class getAmazonItemDetails_result:
20825 
  """
20826 
  Attributes:
20827 
   - success
20828 
  """
20829 
 
20830 
  thrift_spec = (
20831 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
20832 
  )
20833 
 
20834 
  def __init__(self, success=None,):
20835 
    self.success = success
20836 
 
20837 
  def read(self, iprot):
20838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20840 
      return
20841 
    iprot.readStructBegin()
20842 
    while True:
20843 
      (fname, ftype, fid) = iprot.readFieldBegin()
20844 
      if ftype == TType.STOP:
20845 
        break
20846 
      if fid == 0:
20847 
        if ftype == TType.STRUCT:
20848 
          self.success = Amazonlisted()
20849 
          self.success.read(iprot)
20850 
        else:
20851 
          iprot.skip(ftype)
20852 
      else:
20853 
        iprot.skip(ftype)
20854 
      iprot.readFieldEnd()
20855 
    iprot.readStructEnd()
20856 
 
20857 
  def write(self, oprot):
20858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20860 
      return
20861 
    oprot.writeStructBegin('getAmazonItemDetails_result')
20862 
    if self.success is not None:
20863 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20864 
      self.success.write(oprot)
20865 
      oprot.writeFieldEnd()
20866 
    oprot.writeFieldStop()
20867 
    oprot.writeStructEnd()
20868 
 
20869 
  def validate(self):
20870 
    return
20871 
 
20872 
 
20873 
  def __repr__(self):
20874 
    L = ['%s=%r' % (key, value)
20875 
      for key, value in self.__dict__.iteritems()]
20876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20877 
 
20878 
  def __eq__(self, other):
20879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20880 
 
20881 
  def __ne__(self, other):
20882 
    return not (self == other)
20883 
 
20884 
class updateAmazonItemDetails_args:
20885 
  """
20886 
  Attributes:
8168 kshitij.so 20887 
   - amazonlisted
7281 kshitij.so 20888 
  """
20889 
 
20890 
  thrift_spec = (
20891 
    None, # 0
8168 kshitij.so 20892 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 20893 
  )
20894 
 
8168 kshitij.so 20895 
  def __init__(self, amazonlisted=None,):
20896 
    self.amazonlisted = amazonlisted
7281 kshitij.so 20897 
 
20898 
  def read(self, iprot):
20899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20901 
      return
20902 
    iprot.readStructBegin()
20903 
    while True:
20904 
      (fname, ftype, fid) = iprot.readFieldBegin()
20905 
      if ftype == TType.STOP:
20906 
        break
20907 
      if fid == 1:
8168 kshitij.so 20908 
        if ftype == TType.STRUCT:
20909 
          self.amazonlisted = Amazonlisted()
20910 
          self.amazonlisted.read(iprot)
7281 kshitij.so 20911 
        else:
20912 
          iprot.skip(ftype)
20913 
      else:
20914 
        iprot.skip(ftype)
20915 
      iprot.readFieldEnd()
20916 
    iprot.readStructEnd()
20917 
 
20918 
  def write(self, oprot):
20919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20921 
      return
20922 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 20923 
    if self.amazonlisted is not None:
20924 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20925 
      self.amazonlisted.write(oprot)
7281 kshitij.so 20926 
      oprot.writeFieldEnd()
20927 
    oprot.writeFieldStop()
20928 
    oprot.writeStructEnd()
20929 
 
20930 
  def validate(self):
20931 
    return
20932 
 
20933 
 
20934 
  def __repr__(self):
20935 
    L = ['%s=%r' % (key, value)
20936 
      for key, value in self.__dict__.iteritems()]
20937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20938 
 
20939 
  def __eq__(self, other):
20940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20941 
 
20942 
  def __ne__(self, other):
20943 
    return not (self == other)
20944 
 
20945 
class updateAmazonItemDetails_result:
20946 
 
20947 
  thrift_spec = (
20948 
  )
20949 
 
20950 
  def read(self, iprot):
20951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20953 
      return
20954 
    iprot.readStructBegin()
20955 
    while True:
20956 
      (fname, ftype, fid) = iprot.readFieldBegin()
20957 
      if ftype == TType.STOP:
20958 
        break
20959 
      else:
20960 
        iprot.skip(ftype)
20961 
      iprot.readFieldEnd()
20962 
    iprot.readStructEnd()
20963 
 
20964 
  def write(self, oprot):
20965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20967 
      return
20968 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
20969 
    oprot.writeFieldStop()
20970 
    oprot.writeStructEnd()
20971 
 
20972 
  def validate(self):
20973 
    return
20974 
 
20975 
 
20976 
  def __repr__(self):
20977 
    L = ['%s=%r' % (key, value)
20978 
      for key, value in self.__dict__.iteritems()]
20979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20980 
 
20981 
  def __eq__(self, other):
20982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20983 
 
20984 
  def __ne__(self, other):
20985 
    return not (self == other)
20986 
 
20987 
class addAmazonItem_args:
20988 
  """
20989 
  Attributes:
20990 
   - amazonlisted
20991 
  """
20992 
 
20993 
  thrift_spec = (
20994 
    None, # 0
20995 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
20996 
  )
20997 
 
20998 
  def __init__(self, amazonlisted=None,):
20999 
    self.amazonlisted = amazonlisted
21000 
 
21001 
  def read(self, iprot):
21002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21004 
      return
21005 
    iprot.readStructBegin()
21006 
    while True:
21007 
      (fname, ftype, fid) = iprot.readFieldBegin()
21008 
      if ftype == TType.STOP:
21009 
        break
21010 
      if fid == 1:
21011 
        if ftype == TType.STRUCT:
21012 
          self.amazonlisted = Amazonlisted()
21013 
          self.amazonlisted.read(iprot)
21014 
        else:
21015 
          iprot.skip(ftype)
21016 
      else:
21017 
        iprot.skip(ftype)
21018 
      iprot.readFieldEnd()
21019 
    iprot.readStructEnd()
21020 
 
21021 
  def write(self, oprot):
21022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21024 
      return
21025 
    oprot.writeStructBegin('addAmazonItem_args')
21026 
    if self.amazonlisted is not None:
21027 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
21028 
      self.amazonlisted.write(oprot)
21029 
      oprot.writeFieldEnd()
21030 
    oprot.writeFieldStop()
21031 
    oprot.writeStructEnd()
21032 
 
21033 
  def validate(self):
21034 
    return
21035 
 
21036 
 
21037 
  def __repr__(self):
21038 
    L = ['%s=%r' % (key, value)
21039 
      for key, value in self.__dict__.iteritems()]
21040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21041 
 
21042 
  def __eq__(self, other):
21043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21044 
 
21045 
  def __ne__(self, other):
21046 
    return not (self == other)
21047 
 
21048 
class addAmazonItem_result:
21049 
 
21050 
  thrift_spec = (
21051 
  )
21052 
 
21053 
  def read(self, iprot):
21054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21056 
      return
21057 
    iprot.readStructBegin()
21058 
    while True:
21059 
      (fname, ftype, fid) = iprot.readFieldBegin()
21060 
      if ftype == TType.STOP:
21061 
        break
21062 
      else:
21063 
        iprot.skip(ftype)
21064 
      iprot.readFieldEnd()
21065 
    iprot.readStructEnd()
21066 
 
21067 
  def write(self, oprot):
21068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21070 
      return
21071 
    oprot.writeStructBegin('addAmazonItem_result')
21072 
    oprot.writeFieldStop()
21073 
    oprot.writeStructEnd()
21074 
 
21075 
  def validate(self):
21076 
    return
21077 
 
21078 
 
21079 
  def __repr__(self):
21080 
    L = ['%s=%r' % (key, value)
21081 
      for key, value in self.__dict__.iteritems()]
21082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21083 
 
21084 
  def __eq__(self, other):
21085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21086 
 
21087 
  def __ne__(self, other):
21088 
    return not (self == other)
7291 vikram.rag 21089 
 
21090 
class getAsinItems_args:
21091 
 
21092 
  thrift_spec = (
21093 
  )
21094 
 
21095 
  def read(self, iprot):
21096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21098 
      return
21099 
    iprot.readStructBegin()
21100 
    while True:
21101 
      (fname, ftype, fid) = iprot.readFieldBegin()
21102 
      if ftype == TType.STOP:
21103 
        break
21104 
      else:
21105 
        iprot.skip(ftype)
21106 
      iprot.readFieldEnd()
21107 
    iprot.readStructEnd()
21108 
 
21109 
  def write(self, oprot):
21110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21112 
      return
21113 
    oprot.writeStructBegin('getAsinItems_args')
21114 
    oprot.writeFieldStop()
21115 
    oprot.writeStructEnd()
21116 
 
21117 
  def validate(self):
21118 
    return
21119 
 
21120 
 
21121 
  def __repr__(self):
21122 
    L = ['%s=%r' % (key, value)
21123 
      for key, value in self.__dict__.iteritems()]
21124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21125 
 
21126 
  def __eq__(self, other):
21127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21128 
 
21129 
  def __ne__(self, other):
21130 
    return not (self == other)
21131 
 
21132 
class getAsinItems_result:
21133 
  """
21134 
  Attributes:
21135 
   - success
21136 
  """
21137 
 
21138 
  thrift_spec = (
21139 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21140 
  )
21141 
 
21142 
  def __init__(self, success=None,):
21143 
    self.success = success
21144 
 
21145 
  def read(self, iprot):
21146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21148 
      return
21149 
    iprot.readStructBegin()
21150 
    while True:
21151 
      (fname, ftype, fid) = iprot.readFieldBegin()
21152 
      if ftype == TType.STOP:
21153 
        break
21154 
      if fid == 0:
21155 
        if ftype == TType.LIST:
21156 
          self.success = []
9155 kshitij.so 21157 
          (_etype442, _size439) = iprot.readListBegin()
21158 
          for _i443 in xrange(_size439):
21159 
            _elem444 = Item()
21160 
            _elem444.read(iprot)
21161 
            self.success.append(_elem444)
7291 vikram.rag 21162 
          iprot.readListEnd()
21163 
        else:
21164 
          iprot.skip(ftype)
21165 
      else:
21166 
        iprot.skip(ftype)
21167 
      iprot.readFieldEnd()
21168 
    iprot.readStructEnd()
21169 
 
21170 
  def write(self, oprot):
21171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21173 
      return
21174 
    oprot.writeStructBegin('getAsinItems_result')
21175 
    if self.success is not None:
21176 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21177 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21178 
      for iter445 in self.success:
21179 
        iter445.write(oprot)
7291 vikram.rag 21180 
      oprot.writeListEnd()
21181 
      oprot.writeFieldEnd()
21182 
    oprot.writeFieldStop()
21183 
    oprot.writeStructEnd()
21184 
 
21185 
  def validate(self):
21186 
    return
21187 
 
21188 
 
21189 
  def __repr__(self):
21190 
    L = ['%s=%r' % (key, value)
21191 
      for key, value in self.__dict__.iteritems()]
21192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21193 
 
21194 
  def __eq__(self, other):
21195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21196 
 
21197 
  def __ne__(self, other):
21198 
    return not (self == other)
21199 
 
21200 
class getAllFbaListedItems_args:
21201 
 
21202 
  thrift_spec = (
21203 
  )
21204 
 
21205 
  def read(self, iprot):
21206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21208 
      return
21209 
    iprot.readStructBegin()
21210 
    while True:
21211 
      (fname, ftype, fid) = iprot.readFieldBegin()
21212 
      if ftype == TType.STOP:
21213 
        break
21214 
      else:
21215 
        iprot.skip(ftype)
21216 
      iprot.readFieldEnd()
21217 
    iprot.readStructEnd()
21218 
 
21219 
  def write(self, oprot):
21220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21222 
      return
21223 
    oprot.writeStructBegin('getAllFbaListedItems_args')
21224 
    oprot.writeFieldStop()
21225 
    oprot.writeStructEnd()
21226 
 
21227 
  def validate(self):
21228 
    return
21229 
 
21230 
 
21231 
  def __repr__(self):
21232 
    L = ['%s=%r' % (key, value)
21233 
      for key, value in self.__dict__.iteritems()]
21234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21235 
 
21236 
  def __eq__(self, other):
21237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21238 
 
21239 
  def __ne__(self, other):
21240 
    return not (self == other)
21241 
 
21242 
class getAllFbaListedItems_result:
21243 
  """
21244 
  Attributes:
21245 
   - success
21246 
  """
21247 
 
21248 
  thrift_spec = (
21249 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21250 
  )
21251 
 
21252 
  def __init__(self, success=None,):
21253 
    self.success = success
21254 
 
21255 
  def read(self, iprot):
21256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21258 
      return
21259 
    iprot.readStructBegin()
21260 
    while True:
21261 
      (fname, ftype, fid) = iprot.readFieldBegin()
21262 
      if ftype == TType.STOP:
21263 
        break
21264 
      if fid == 0:
21265 
        if ftype == TType.LIST:
21266 
          self.success = []
9155 kshitij.so 21267 
          (_etype449, _size446) = iprot.readListBegin()
21268 
          for _i450 in xrange(_size446):
21269 
            _elem451 = Amazonlisted()
21270 
            _elem451.read(iprot)
21271 
            self.success.append(_elem451)
7291 vikram.rag 21272 
          iprot.readListEnd()
21273 
        else:
21274 
          iprot.skip(ftype)
21275 
      else:
21276 
        iprot.skip(ftype)
21277 
      iprot.readFieldEnd()
21278 
    iprot.readStructEnd()
21279 
 
21280 
  def write(self, oprot):
21281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21283 
      return
21284 
    oprot.writeStructBegin('getAllFbaListedItems_result')
21285 
    if self.success is not None:
21286 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21287 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21288 
      for iter452 in self.success:
21289 
        iter452.write(oprot)
7291 vikram.rag 21290 
      oprot.writeListEnd()
21291 
      oprot.writeFieldEnd()
21292 
    oprot.writeFieldStop()
21293 
    oprot.writeStructEnd()
21294 
 
21295 
  def validate(self):
21296 
    return
21297 
 
21298 
 
21299 
  def __repr__(self):
21300 
    L = ['%s=%r' % (key, value)
21301 
      for key, value in self.__dict__.iteritems()]
21302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21303 
 
21304 
  def __eq__(self, other):
21305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21306 
 
21307 
  def __ne__(self, other):
21308 
    return not (self == other)
21309 
 
21310 
class getAllNonFbaListedItems_args:
21311 
 
21312 
  thrift_spec = (
21313 
  )
21314 
 
21315 
  def read(self, iprot):
21316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21318 
      return
21319 
    iprot.readStructBegin()
21320 
    while True:
21321 
      (fname, ftype, fid) = iprot.readFieldBegin()
21322 
      if ftype == TType.STOP:
21323 
        break
21324 
      else:
21325 
        iprot.skip(ftype)
21326 
      iprot.readFieldEnd()
21327 
    iprot.readStructEnd()
21328 
 
21329 
  def write(self, oprot):
21330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21332 
      return
21333 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
21334 
    oprot.writeFieldStop()
21335 
    oprot.writeStructEnd()
21336 
 
21337 
  def validate(self):
21338 
    return
21339 
 
21340 
 
21341 
  def __repr__(self):
21342 
    L = ['%s=%r' % (key, value)
21343 
      for key, value in self.__dict__.iteritems()]
21344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21345 
 
21346 
  def __eq__(self, other):
21347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21348 
 
21349 
  def __ne__(self, other):
21350 
    return not (self == other)
21351 
 
21352 
class getAllNonFbaListedItems_result:
21353 
  """
21354 
  Attributes:
21355 
   - success
21356 
  """
21357 
 
21358 
  thrift_spec = (
21359 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21360 
  )
21361 
 
21362 
  def __init__(self, success=None,):
21363 
    self.success = success
21364 
 
21365 
  def read(self, iprot):
21366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21368 
      return
21369 
    iprot.readStructBegin()
21370 
    while True:
21371 
      (fname, ftype, fid) = iprot.readFieldBegin()
21372 
      if ftype == TType.STOP:
21373 
        break
21374 
      if fid == 0:
21375 
        if ftype == TType.LIST:
21376 
          self.success = []
9155 kshitij.so 21377 
          (_etype456, _size453) = iprot.readListBegin()
21378 
          for _i457 in xrange(_size453):
21379 
            _elem458 = Amazonlisted()
21380 
            _elem458.read(iprot)
21381 
            self.success.append(_elem458)
7291 vikram.rag 21382 
          iprot.readListEnd()
21383 
        else:
21384 
          iprot.skip(ftype)
21385 
      else:
21386 
        iprot.skip(ftype)
21387 
      iprot.readFieldEnd()
21388 
    iprot.readStructEnd()
21389 
 
21390 
  def write(self, oprot):
21391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21393 
      return
21394 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
21395 
    if self.success is not None:
21396 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21397 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21398 
      for iter459 in self.success:
21399 
        iter459.write(oprot)
7291 vikram.rag 21400 
      oprot.writeListEnd()
21401 
      oprot.writeFieldEnd()
21402 
    oprot.writeFieldStop()
21403 
    oprot.writeStructEnd()
21404 
 
21405 
  def validate(self):
21406 
    return
21407 
 
21408 
 
21409 
  def __repr__(self):
21410 
    L = ['%s=%r' % (key, value)
21411 
      for key, value in self.__dict__.iteritems()]
21412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21413 
 
21414 
  def __eq__(self, other):
21415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21416 
 
21417 
  def __ne__(self, other):
21418 
    return not (self == other)
7460 kshitij.so 21419 
 
21420 
class updateItemInventory_args:
21421 
  """
21422 
  Attributes:
21423 
   - itemId
21424 
   - holdInventory
21425 
   - defaultInventory
21426 
  """
21427 
 
21428 
  thrift_spec = (
21429 
    None, # 0
21430 
    (1, TType.I64, 'itemId', None, None, ), # 1
21431 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
21432 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
21433 
  )
21434 
 
21435 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
21436 
    self.itemId = itemId
21437 
    self.holdInventory = holdInventory
21438 
    self.defaultInventory = defaultInventory
21439 
 
21440 
  def read(self, iprot):
21441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21443 
      return
21444 
    iprot.readStructBegin()
21445 
    while True:
21446 
      (fname, ftype, fid) = iprot.readFieldBegin()
21447 
      if ftype == TType.STOP:
21448 
        break
21449 
      if fid == 1:
21450 
        if ftype == TType.I64:
21451 
          self.itemId = iprot.readI64();
21452 
        else:
21453 
          iprot.skip(ftype)
21454 
      elif fid == 2:
21455 
        if ftype == TType.I64:
21456 
          self.holdInventory = iprot.readI64();
21457 
        else:
21458 
          iprot.skip(ftype)
21459 
      elif fid == 3:
21460 
        if ftype == TType.I64:
21461 
          self.defaultInventory = iprot.readI64();
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('updateItemInventory_args')
21474 
    if self.itemId is not None:
21475 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21476 
      oprot.writeI64(self.itemId)
21477 
      oprot.writeFieldEnd()
21478 
    if self.holdInventory is not None:
21479 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
21480 
      oprot.writeI64(self.holdInventory)
21481 
      oprot.writeFieldEnd()
21482 
    if self.defaultInventory is not None:
21483 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
21484 
      oprot.writeI64(self.defaultInventory)
21485 
      oprot.writeFieldEnd()
21486 
    oprot.writeFieldStop()
21487 
    oprot.writeStructEnd()
21488 
 
21489 
  def validate(self):
21490 
    return
21491 
 
21492 
 
21493 
  def __repr__(self):
21494 
    L = ['%s=%r' % (key, value)
21495 
      for key, value in self.__dict__.iteritems()]
21496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21497 
 
21498 
  def __eq__(self, other):
21499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21500 
 
21501 
  def __ne__(self, other):
21502 
    return not (self == other)
21503 
 
21504 
class updateItemInventory_result:
21505 
  """
21506 
  Attributes:
21507 
   - success
21508 
  """
21509 
 
21510 
  thrift_spec = (
21511 
    (0, TType.BOOL, 'success', None, None, ), # 0
21512 
  )
21513 
 
21514 
  def __init__(self, success=None,):
21515 
    self.success = success
21516 
 
21517 
  def read(self, iprot):
21518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21520 
      return
21521 
    iprot.readStructBegin()
21522 
    while True:
21523 
      (fname, ftype, fid) = iprot.readFieldBegin()
21524 
      if ftype == TType.STOP:
21525 
        break
21526 
      if fid == 0:
21527 
        if ftype == TType.BOOL:
21528 
          self.success = iprot.readBool();
21529 
        else:
21530 
          iprot.skip(ftype)
21531 
      else:
21532 
        iprot.skip(ftype)
21533 
      iprot.readFieldEnd()
21534 
    iprot.readStructEnd()
21535 
 
21536 
  def write(self, oprot):
21537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21539 
      return
21540 
    oprot.writeStructBegin('updateItemInventory_result')
21541 
    if self.success is not None:
21542 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21543 
      oprot.writeBool(self.success)
21544 
      oprot.writeFieldEnd()
21545 
    oprot.writeFieldStop()
21546 
    oprot.writeStructEnd()
21547 
 
21548 
  def validate(self):
21549 
    return
21550 
 
21551 
 
21552 
  def __repr__(self):
21553 
    L = ['%s=%r' % (key, value)
21554 
      for key, value in self.__dict__.iteritems()]
21555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21556 
 
21557 
  def __eq__(self, other):
21558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21559 
 
21560 
  def __ne__(self, other):
21561 
    return not (self == other)
7770 kshitij.so 21562 
 
21563 
class updateTimestampForAmazonFeeds_args:
21564 
  """
21565 
  Attributes:
21566 
   - type
21567 
   - sku
21568 
   - timestamp
21569 
  """
21570 
 
21571 
  thrift_spec = (
21572 
    None, # 0
21573 
    (1, TType.STRING, 'type', None, None, ), # 1
21574 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
21575 
    (3, TType.I64, 'timestamp', None, None, ), # 3
21576 
  )
21577 
 
21578 
  def __init__(self, type=None, sku=None, timestamp=None,):
21579 
    self.type = type
21580 
    self.sku = sku
21581 
    self.timestamp = timestamp
21582 
 
21583 
  def read(self, iprot):
21584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21586 
      return
21587 
    iprot.readStructBegin()
21588 
    while True:
21589 
      (fname, ftype, fid) = iprot.readFieldBegin()
21590 
      if ftype == TType.STOP:
21591 
        break
21592 
      if fid == 1:
21593 
        if ftype == TType.STRING:
21594 
          self.type = iprot.readString();
21595 
        else:
21596 
          iprot.skip(ftype)
21597 
      elif fid == 2:
21598 
        if ftype == TType.LIST:
21599 
          self.sku = []
9155 kshitij.so 21600 
          (_etype463, _size460) = iprot.readListBegin()
21601 
          for _i464 in xrange(_size460):
21602 
            _elem465 = iprot.readI64();
21603 
            self.sku.append(_elem465)
7770 kshitij.so 21604 
          iprot.readListEnd()
21605 
        else:
21606 
          iprot.skip(ftype)
21607 
      elif fid == 3:
21608 
        if ftype == TType.I64:
21609 
          self.timestamp = iprot.readI64();
21610 
        else:
21611 
          iprot.skip(ftype)
21612 
      else:
21613 
        iprot.skip(ftype)
21614 
      iprot.readFieldEnd()
21615 
    iprot.readStructEnd()
21616 
 
21617 
  def write(self, oprot):
21618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21620 
      return
21621 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
21622 
    if self.type is not None:
21623 
      oprot.writeFieldBegin('type', TType.STRING, 1)
21624 
      oprot.writeString(self.type)
21625 
      oprot.writeFieldEnd()
21626 
    if self.sku is not None:
21627 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
21628 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 21629 
      for iter466 in self.sku:
21630 
        oprot.writeI64(iter466)
7770 kshitij.so 21631 
      oprot.writeListEnd()
21632 
      oprot.writeFieldEnd()
21633 
    if self.timestamp is not None:
21634 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
21635 
      oprot.writeI64(self.timestamp)
21636 
      oprot.writeFieldEnd()
21637 
    oprot.writeFieldStop()
21638 
    oprot.writeStructEnd()
21639 
 
21640 
  def validate(self):
21641 
    return
21642 
 
21643 
 
21644 
  def __repr__(self):
21645 
    L = ['%s=%r' % (key, value)
21646 
      for key, value in self.__dict__.iteritems()]
21647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21648 
 
21649 
  def __eq__(self, other):
21650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21651 
 
21652 
  def __ne__(self, other):
21653 
    return not (self == other)
21654 
 
21655 
class updateTimestampForAmazonFeeds_result:
21656 
  """
21657 
  Attributes:
21658 
   - success
21659 
  """
21660 
 
21661 
  thrift_spec = (
21662 
    (0, TType.BOOL, 'success', None, None, ), # 0
21663 
  )
21664 
 
21665 
  def __init__(self, success=None,):
21666 
    self.success = success
21667 
 
21668 
  def read(self, iprot):
21669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21671 
      return
21672 
    iprot.readStructBegin()
21673 
    while True:
21674 
      (fname, ftype, fid) = iprot.readFieldBegin()
21675 
      if ftype == TType.STOP:
21676 
        break
21677 
      if fid == 0:
21678 
        if ftype == TType.BOOL:
21679 
          self.success = iprot.readBool();
21680 
        else:
21681 
          iprot.skip(ftype)
21682 
      else:
21683 
        iprot.skip(ftype)
21684 
      iprot.readFieldEnd()
21685 
    iprot.readStructEnd()
21686 
 
21687 
  def write(self, oprot):
21688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21690 
      return
21691 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
21692 
    if self.success is not None:
21693 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21694 
      oprot.writeBool(self.success)
21695 
      oprot.writeFieldEnd()
21696 
    oprot.writeFieldStop()
21697 
    oprot.writeStructEnd()
21698 
 
21699 
  def validate(self):
21700 
    return
21701 
 
21702 
 
21703 
  def __repr__(self):
21704 
    L = ['%s=%r' % (key, value)
21705 
      for key, value in self.__dict__.iteritems()]
21706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21707 
 
21708 
  def __eq__(self, other):
21709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21710 
 
21711 
  def __ne__(self, other):
21712 
    return not (self == other)
7897 amar.kumar 21713 
 
21714 
class getAllParentCategories_args:
21715 
 
21716 
  thrift_spec = (
21717 
  )
21718 
 
21719 
  def read(self, iprot):
21720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21722 
      return
21723 
    iprot.readStructBegin()
21724 
    while True:
21725 
      (fname, ftype, fid) = iprot.readFieldBegin()
21726 
      if ftype == TType.STOP:
21727 
        break
21728 
      else:
21729 
        iprot.skip(ftype)
21730 
      iprot.readFieldEnd()
21731 
    iprot.readStructEnd()
21732 
 
21733 
  def write(self, oprot):
21734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21736 
      return
21737 
    oprot.writeStructBegin('getAllParentCategories_args')
21738 
    oprot.writeFieldStop()
21739 
    oprot.writeStructEnd()
21740 
 
21741 
  def validate(self):
21742 
    return
21743 
 
21744 
 
21745 
  def __repr__(self):
21746 
    L = ['%s=%r' % (key, value)
21747 
      for key, value in self.__dict__.iteritems()]
21748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21749 
 
21750 
  def __eq__(self, other):
21751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21752 
 
21753 
  def __ne__(self, other):
21754 
    return not (self == other)
21755 
 
21756 
class getAllParentCategories_result:
21757 
  """
21758 
  Attributes:
21759 
   - success
21760 
  """
21761 
 
21762 
  thrift_spec = (
21763 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
21764 
  )
21765 
 
21766 
  def __init__(self, success=None,):
21767 
    self.success = success
21768 
 
21769 
  def read(self, iprot):
21770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21772 
      return
21773 
    iprot.readStructBegin()
21774 
    while True:
21775 
      (fname, ftype, fid) = iprot.readFieldBegin()
21776 
      if ftype == TType.STOP:
21777 
        break
21778 
      if fid == 0:
21779 
        if ftype == TType.LIST:
21780 
          self.success = []
9155 kshitij.so 21781 
          (_etype470, _size467) = iprot.readListBegin()
21782 
          for _i471 in xrange(_size467):
21783 
            _elem472 = Category()
21784 
            _elem472.read(iprot)
21785 
            self.success.append(_elem472)
7897 amar.kumar 21786 
          iprot.readListEnd()
21787 
        else:
21788 
          iprot.skip(ftype)
21789 
      else:
21790 
        iprot.skip(ftype)
21791 
      iprot.readFieldEnd()
21792 
    iprot.readStructEnd()
21793 
 
21794 
  def write(self, oprot):
21795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21797 
      return
21798 
    oprot.writeStructBegin('getAllParentCategories_result')
21799 
    if self.success is not None:
21800 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21801 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21802 
      for iter473 in self.success:
21803 
        iter473.write(oprot)
7897 amar.kumar 21804 
      oprot.writeListEnd()
21805 
      oprot.writeFieldEnd()
21806 
    oprot.writeFieldStop()
21807 
    oprot.writeStructEnd()
21808 
 
21809 
  def validate(self):
21810 
    return
21811 
 
21812 
 
21813 
  def __repr__(self):
21814 
    L = ['%s=%r' % (key, value)
21815 
      for key, value in self.__dict__.iteritems()]
21816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21817 
 
21818 
  def __eq__(self, other):
21819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21820 
 
21821 
  def __ne__(self, other):
21822 
    return not (self == other)
7977 kshitij.so 21823 
 
21824 
class addPageViewEvent_args:
21825 
  """
21826 
  Attributes:
21827 
   - pageViewEvents
21828 
  """
21829 
 
21830 
  thrift_spec = (
21831 
    None, # 0
21832 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
21833 
  )
21834 
 
21835 
  def __init__(self, pageViewEvents=None,):
21836 
    self.pageViewEvents = pageViewEvents
21837 
 
21838 
  def read(self, iprot):
21839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21841 
      return
21842 
    iprot.readStructBegin()
21843 
    while True:
21844 
      (fname, ftype, fid) = iprot.readFieldBegin()
21845 
      if ftype == TType.STOP:
21846 
        break
21847 
      if fid == 1:
21848 
        if ftype == TType.STRUCT:
21849 
          self.pageViewEvents = PageViewEvents()
21850 
          self.pageViewEvents.read(iprot)
21851 
        else:
21852 
          iprot.skip(ftype)
21853 
      else:
21854 
        iprot.skip(ftype)
21855 
      iprot.readFieldEnd()
21856 
    iprot.readStructEnd()
21857 
 
21858 
  def write(self, oprot):
21859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21861 
      return
21862 
    oprot.writeStructBegin('addPageViewEvent_args')
21863 
    if self.pageViewEvents is not None:
21864 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
21865 
      self.pageViewEvents.write(oprot)
21866 
      oprot.writeFieldEnd()
21867 
    oprot.writeFieldStop()
21868 
    oprot.writeStructEnd()
21869 
 
21870 
  def validate(self):
21871 
    return
21872 
 
21873 
 
21874 
  def __repr__(self):
21875 
    L = ['%s=%r' % (key, value)
21876 
      for key, value in self.__dict__.iteritems()]
21877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21878 
 
21879 
  def __eq__(self, other):
21880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21881 
 
21882 
  def __ne__(self, other):
21883 
    return not (self == other)
21884 
 
21885 
class addPageViewEvent_result:
21886 
 
21887 
  thrift_spec = (
21888 
  )
21889 
 
21890 
  def read(self, iprot):
21891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21893 
      return
21894 
    iprot.readStructBegin()
21895 
    while True:
21896 
      (fname, ftype, fid) = iprot.readFieldBegin()
21897 
      if ftype == TType.STOP:
21898 
        break
21899 
      else:
21900 
        iprot.skip(ftype)
21901 
      iprot.readFieldEnd()
21902 
    iprot.readStructEnd()
21903 
 
21904 
  def write(self, oprot):
21905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21907 
      return
21908 
    oprot.writeStructBegin('addPageViewEvent_result')
21909 
    oprot.writeFieldStop()
21910 
    oprot.writeStructEnd()
21911 
 
21912 
  def validate(self):
21913 
    return
21914 
 
21915 
 
21916 
  def __repr__(self):
21917 
    L = ['%s=%r' % (key, value)
21918 
      for key, value in self.__dict__.iteritems()]
21919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21920 
 
21921 
  def __eq__(self, other):
21922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21923 
 
21924 
  def __ne__(self, other):
21925 
    return not (self == other)
21926 
 
21927 
class addCartEvent_args:
21928 
  """
21929 
  Attributes:
21930 
   - cartEvents
21931 
  """
21932 
 
21933 
  thrift_spec = (
21934 
    None, # 0
21935 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
21936 
  )
21937 
 
21938 
  def __init__(self, cartEvents=None,):
21939 
    self.cartEvents = cartEvents
21940 
 
21941 
  def read(self, iprot):
21942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21944 
      return
21945 
    iprot.readStructBegin()
21946 
    while True:
21947 
      (fname, ftype, fid) = iprot.readFieldBegin()
21948 
      if ftype == TType.STOP:
21949 
        break
21950 
      if fid == 1:
21951 
        if ftype == TType.STRUCT:
21952 
          self.cartEvents = CartEvents()
21953 
          self.cartEvents.read(iprot)
21954 
        else:
21955 
          iprot.skip(ftype)
21956 
      else:
21957 
        iprot.skip(ftype)
21958 
      iprot.readFieldEnd()
21959 
    iprot.readStructEnd()
21960 
 
21961 
  def write(self, oprot):
21962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21964 
      return
21965 
    oprot.writeStructBegin('addCartEvent_args')
21966 
    if self.cartEvents is not None:
21967 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
21968 
      self.cartEvents.write(oprot)
21969 
      oprot.writeFieldEnd()
21970 
    oprot.writeFieldStop()
21971 
    oprot.writeStructEnd()
21972 
 
21973 
  def validate(self):
21974 
    return
21975 
 
21976 
 
21977 
  def __repr__(self):
21978 
    L = ['%s=%r' % (key, value)
21979 
      for key, value in self.__dict__.iteritems()]
21980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21981 
 
21982 
  def __eq__(self, other):
21983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21984 
 
21985 
  def __ne__(self, other):
21986 
    return not (self == other)
21987 
 
21988 
class addCartEvent_result:
21989 
 
21990 
  thrift_spec = (
21991 
  )
21992 
 
21993 
  def read(self, iprot):
21994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21996 
      return
21997 
    iprot.readStructBegin()
21998 
    while True:
21999 
      (fname, ftype, fid) = iprot.readFieldBegin()
22000 
      if ftype == TType.STOP:
22001 
        break
22002 
      else:
22003 
        iprot.skip(ftype)
22004 
      iprot.readFieldEnd()
22005 
    iprot.readStructEnd()
22006 
 
22007 
  def write(self, oprot):
22008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22010 
      return
22011 
    oprot.writeStructBegin('addCartEvent_result')
22012 
    oprot.writeFieldStop()
22013 
    oprot.writeStructEnd()
22014 
 
22015 
  def validate(self):
22016 
    return
22017 
 
22018 
 
22019 
  def __repr__(self):
22020 
    L = ['%s=%r' % (key, value)
22021 
      for key, value in self.__dict__.iteritems()]
22022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22023 
 
22024 
  def __eq__(self, other):
22025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22026 
 
22027 
  def __ne__(self, other):
22028 
    return not (self == other)
8139 kshitij.so 22029 
 
8182 amar.kumar 22030 
class addEbayItem_args:
22031 
  """
22032 
  Attributes:
22033 
   - ebayItem
22034 
  """
22035 
 
22036 
  thrift_spec = (
22037 
    None, # 0
22038 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22039 
  )
22040 
 
22041 
  def __init__(self, ebayItem=None,):
22042 
    self.ebayItem = ebayItem
22043 
 
22044 
  def read(self, iprot):
22045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22047 
      return
22048 
    iprot.readStructBegin()
22049 
    while True:
22050 
      (fname, ftype, fid) = iprot.readFieldBegin()
22051 
      if ftype == TType.STOP:
22052 
        break
22053 
      if fid == 1:
22054 
        if ftype == TType.STRUCT:
22055 
          self.ebayItem = EbayItem()
22056 
          self.ebayItem.read(iprot)
22057 
        else:
22058 
          iprot.skip(ftype)
22059 
      else:
22060 
        iprot.skip(ftype)
22061 
      iprot.readFieldEnd()
22062 
    iprot.readStructEnd()
22063 
 
22064 
  def write(self, oprot):
22065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22067 
      return
22068 
    oprot.writeStructBegin('addEbayItem_args')
22069 
    if self.ebayItem is not None:
22070 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22071 
      self.ebayItem.write(oprot)
22072 
      oprot.writeFieldEnd()
22073 
    oprot.writeFieldStop()
22074 
    oprot.writeStructEnd()
22075 
 
22076 
  def validate(self):
22077 
    return
22078 
 
22079 
 
22080 
  def __repr__(self):
22081 
    L = ['%s=%r' % (key, value)
22082 
      for key, value in self.__dict__.iteritems()]
22083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22084 
 
22085 
  def __eq__(self, other):
22086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22087 
 
22088 
  def __ne__(self, other):
22089 
    return not (self == other)
22090 
 
22091 
class addEbayItem_result:
22092 
 
22093 
  thrift_spec = (
22094 
  )
22095 
 
22096 
  def read(self, iprot):
22097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22099 
      return
22100 
    iprot.readStructBegin()
22101 
    while True:
22102 
      (fname, ftype, fid) = iprot.readFieldBegin()
22103 
      if ftype == TType.STOP:
22104 
        break
22105 
      else:
22106 
        iprot.skip(ftype)
22107 
      iprot.readFieldEnd()
22108 
    iprot.readStructEnd()
22109 
 
22110 
  def write(self, oprot):
22111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22113 
      return
22114 
    oprot.writeStructBegin('addEbayItem_result')
22115 
    oprot.writeFieldStop()
22116 
    oprot.writeStructEnd()
22117 
 
22118 
  def validate(self):
22119 
    return
22120 
 
22121 
 
22122 
  def __repr__(self):
22123 
    L = ['%s=%r' % (key, value)
22124 
      for key, value in self.__dict__.iteritems()]
22125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22126 
 
22127 
  def __eq__(self, other):
22128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22129 
 
22130 
  def __ne__(self, other):
22131 
    return not (self == other)
22132 
 
22133 
class getEbayItem_args:
22134 
  """
22135 
  Attributes:
22136 
   - listingId
22137 
  """
22138 
 
22139 
  thrift_spec = (
22140 
    None, # 0
22141 
    (1, TType.STRING, 'listingId', None, None, ), # 1
22142 
  )
22143 
 
22144 
  def __init__(self, listingId=None,):
22145 
    self.listingId = listingId
22146 
 
22147 
  def read(self, iprot):
22148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22150 
      return
22151 
    iprot.readStructBegin()
22152 
    while True:
22153 
      (fname, ftype, fid) = iprot.readFieldBegin()
22154 
      if ftype == TType.STOP:
22155 
        break
22156 
      if fid == 1:
22157 
        if ftype == TType.STRING:
22158 
          self.listingId = iprot.readString();
22159 
        else:
22160 
          iprot.skip(ftype)
22161 
      else:
22162 
        iprot.skip(ftype)
22163 
      iprot.readFieldEnd()
22164 
    iprot.readStructEnd()
22165 
 
22166 
  def write(self, oprot):
22167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22169 
      return
22170 
    oprot.writeStructBegin('getEbayItem_args')
22171 
    if self.listingId is not None:
22172 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
22173 
      oprot.writeString(self.listingId)
22174 
      oprot.writeFieldEnd()
22175 
    oprot.writeFieldStop()
22176 
    oprot.writeStructEnd()
22177 
 
22178 
  def validate(self):
22179 
    return
22180 
 
22181 
 
22182 
  def __repr__(self):
22183 
    L = ['%s=%r' % (key, value)
22184 
      for key, value in self.__dict__.iteritems()]
22185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22186 
 
22187 
  def __eq__(self, other):
22188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22189 
 
22190 
  def __ne__(self, other):
22191 
    return not (self == other)
22192 
 
22193 
class getEbayItem_result:
22194 
  """
22195 
  Attributes:
22196 
   - success
22197 
  """
22198 
 
22199 
  thrift_spec = (
22200 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
22201 
  )
22202 
 
22203 
  def __init__(self, success=None,):
22204 
    self.success = success
22205 
 
22206 
  def read(self, iprot):
22207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22209 
      return
22210 
    iprot.readStructBegin()
22211 
    while True:
22212 
      (fname, ftype, fid) = iprot.readFieldBegin()
22213 
      if ftype == TType.STOP:
22214 
        break
22215 
      if fid == 0:
22216 
        if ftype == TType.STRUCT:
22217 
          self.success = EbayItem()
22218 
          self.success.read(iprot)
22219 
        else:
22220 
          iprot.skip(ftype)
22221 
      else:
22222 
        iprot.skip(ftype)
22223 
      iprot.readFieldEnd()
22224 
    iprot.readStructEnd()
22225 
 
22226 
  def write(self, oprot):
22227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22229 
      return
22230 
    oprot.writeStructBegin('getEbayItem_result')
22231 
    if self.success is not None:
22232 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22233 
      self.success.write(oprot)
22234 
      oprot.writeFieldEnd()
22235 
    oprot.writeFieldStop()
22236 
    oprot.writeStructEnd()
22237 
 
22238 
  def validate(self):
22239 
    return
22240 
 
22241 
 
22242 
  def __repr__(self):
22243 
    L = ['%s=%r' % (key, value)
22244 
      for key, value in self.__dict__.iteritems()]
22245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22246 
 
22247 
  def __eq__(self, other):
22248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22249 
 
22250 
  def __ne__(self, other):
22251 
    return not (self == other)
22252 
 
22253 
class updateEbayItem_args:
22254 
  """
22255 
  Attributes:
22256 
   - ebayItem
22257 
  """
22258 
 
22259 
  thrift_spec = (
22260 
    None, # 0
22261 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22262 
  )
22263 
 
22264 
  def __init__(self, ebayItem=None,):
22265 
    self.ebayItem = ebayItem
22266 
 
22267 
  def read(self, iprot):
22268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22270 
      return
22271 
    iprot.readStructBegin()
22272 
    while True:
22273 
      (fname, ftype, fid) = iprot.readFieldBegin()
22274 
      if ftype == TType.STOP:
22275 
        break
22276 
      if fid == 1:
22277 
        if ftype == TType.STRUCT:
22278 
          self.ebayItem = EbayItem()
22279 
          self.ebayItem.read(iprot)
22280 
        else:
22281 
          iprot.skip(ftype)
22282 
      else:
22283 
        iprot.skip(ftype)
22284 
      iprot.readFieldEnd()
22285 
    iprot.readStructEnd()
22286 
 
22287 
  def write(self, oprot):
22288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22290 
      return
22291 
    oprot.writeStructBegin('updateEbayItem_args')
22292 
    if self.ebayItem is not None:
22293 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22294 
      self.ebayItem.write(oprot)
22295 
      oprot.writeFieldEnd()
22296 
    oprot.writeFieldStop()
22297 
    oprot.writeStructEnd()
22298 
 
22299 
  def validate(self):
22300 
    return
22301 
 
22302 
 
22303 
  def __repr__(self):
22304 
    L = ['%s=%r' % (key, value)
22305 
      for key, value in self.__dict__.iteritems()]
22306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22307 
 
22308 
  def __eq__(self, other):
22309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22310 
 
22311 
  def __ne__(self, other):
22312 
    return not (self == other)
22313 
 
22314 
class updateEbayItem_result:
22315 
 
22316 
  thrift_spec = (
22317 
  )
22318 
 
22319 
  def read(self, iprot):
22320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22322 
      return
22323 
    iprot.readStructBegin()
22324 
    while True:
22325 
      (fname, ftype, fid) = iprot.readFieldBegin()
22326 
      if ftype == TType.STOP:
22327 
        break
22328 
      else:
22329 
        iprot.skip(ftype)
22330 
      iprot.readFieldEnd()
22331 
    iprot.readStructEnd()
22332 
 
22333 
  def write(self, oprot):
22334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22336 
      return
22337 
    oprot.writeStructBegin('updateEbayItem_result')
22338 
    oprot.writeFieldStop()
22339 
    oprot.writeStructEnd()
22340 
 
22341 
  def validate(self):
22342 
    return
22343 
 
22344 
 
22345 
  def __repr__(self):
22346 
    L = ['%s=%r' % (key, value)
22347 
      for key, value in self.__dict__.iteritems()]
22348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22349 
 
22350 
  def __eq__(self, other):
22351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22352 
 
22353 
  def __ne__(self, other):
22354 
    return not (self == other)
22355 
 
8139 kshitij.so 22356 
class getAmazonListedItems_args:
22357 
  """
22358 
  Attributes:
22359 
   - offset
22360 
   - limit
22361 
  """
22362 
 
22363 
  thrift_spec = (
22364 
    None, # 0
22365 
    (1, TType.I64, 'offset', None, None, ), # 1
22366 
    (2, TType.I64, 'limit', None, None, ), # 2
22367 
  )
22368 
 
22369 
  def __init__(self, offset=None, limit=None,):
22370 
    self.offset = offset
22371 
    self.limit = limit
22372 
 
22373 
  def read(self, iprot):
22374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22376 
      return
22377 
    iprot.readStructBegin()
22378 
    while True:
22379 
      (fname, ftype, fid) = iprot.readFieldBegin()
22380 
      if ftype == TType.STOP:
22381 
        break
22382 
      if fid == 1:
22383 
        if ftype == TType.I64:
22384 
          self.offset = iprot.readI64();
22385 
        else:
22386 
          iprot.skip(ftype)
22387 
      elif fid == 2:
22388 
        if ftype == TType.I64:
22389 
          self.limit = iprot.readI64();
22390 
        else:
22391 
          iprot.skip(ftype)
22392 
      else:
22393 
        iprot.skip(ftype)
22394 
      iprot.readFieldEnd()
22395 
    iprot.readStructEnd()
22396 
 
22397 
  def write(self, oprot):
22398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22400 
      return
22401 
    oprot.writeStructBegin('getAmazonListedItems_args')
22402 
    if self.offset is not None:
22403 
      oprot.writeFieldBegin('offset', TType.I64, 1)
22404 
      oprot.writeI64(self.offset)
22405 
      oprot.writeFieldEnd()
22406 
    if self.limit is not None:
22407 
      oprot.writeFieldBegin('limit', TType.I64, 2)
22408 
      oprot.writeI64(self.limit)
22409 
      oprot.writeFieldEnd()
22410 
    oprot.writeFieldStop()
22411 
    oprot.writeStructEnd()
22412 
 
22413 
  def validate(self):
22414 
    return
22415 
 
22416 
 
22417 
  def __repr__(self):
22418 
    L = ['%s=%r' % (key, value)
22419 
      for key, value in self.__dict__.iteritems()]
22420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22421 
 
22422 
  def __eq__(self, other):
22423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22424 
 
22425 
  def __ne__(self, other):
22426 
    return not (self == other)
22427 
 
22428 
class getAmazonListedItems_result:
22429 
  """
22430 
  Attributes:
22431 
   - success
22432 
  """
22433 
 
22434 
  thrift_spec = (
22435 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22436 
  )
22437 
 
22438 
  def __init__(self, success=None,):
22439 
    self.success = success
22440 
 
22441 
  def read(self, iprot):
22442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22444 
      return
22445 
    iprot.readStructBegin()
22446 
    while True:
22447 
      (fname, ftype, fid) = iprot.readFieldBegin()
22448 
      if ftype == TType.STOP:
22449 
        break
22450 
      if fid == 0:
22451 
        if ftype == TType.LIST:
22452 
          self.success = []
9155 kshitij.so 22453 
          (_etype477, _size474) = iprot.readListBegin()
22454 
          for _i478 in xrange(_size474):
22455 
            _elem479 = Amazonlisted()
22456 
            _elem479.read(iprot)
22457 
            self.success.append(_elem479)
8139 kshitij.so 22458 
          iprot.readListEnd()
22459 
        else:
22460 
          iprot.skip(ftype)
22461 
      else:
22462 
        iprot.skip(ftype)
22463 
      iprot.readFieldEnd()
22464 
    iprot.readStructEnd()
22465 
 
22466 
  def write(self, oprot):
22467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22469 
      return
22470 
    oprot.writeStructBegin('getAmazonListedItems_result')
22471 
    if self.success is not None:
22472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22473 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22474 
      for iter480 in self.success:
22475 
        iter480.write(oprot)
8139 kshitij.so 22476 
      oprot.writeListEnd()
22477 
      oprot.writeFieldEnd()
22478 
    oprot.writeFieldStop()
22479 
    oprot.writeStructEnd()
22480 
 
22481 
  def validate(self):
22482 
    return
22483 
 
22484 
 
22485 
  def __repr__(self):
22486 
    L = ['%s=%r' % (key, value)
22487 
      for key, value in self.__dict__.iteritems()]
22488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22489 
 
22490 
  def __eq__(self, other):
22491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22492 
 
22493 
  def __ne__(self, other):
22494 
    return not (self == other)
8168 kshitij.so 22495 
 
22496 
class updateAmazonAttributesInBulk_args:
22497 
  """
22498 
  Attributes:
22499 
   - amazonlisted
22500 
  """
22501 
 
22502 
  thrift_spec = (
22503 
    None, # 0
22504 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
22505 
  )
22506 
 
22507 
  def __init__(self, amazonlisted=None,):
22508 
    self.amazonlisted = amazonlisted
22509 
 
22510 
  def read(self, iprot):
22511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22513 
      return
22514 
    iprot.readStructBegin()
22515 
    while True:
22516 
      (fname, ftype, fid) = iprot.readFieldBegin()
22517 
      if ftype == TType.STOP:
22518 
        break
22519 
      if fid == 1:
22520 
        if ftype == TType.MAP:
22521 
          self.amazonlisted = {}
9155 kshitij.so 22522 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
22523 
          for _i485 in xrange(_size481):
22524 
            _key486 = iprot.readI64();
22525 
            _val487 = Amazonlisted()
22526 
            _val487.read(iprot)
22527 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 22528 
          iprot.readMapEnd()
22529 
        else:
22530 
          iprot.skip(ftype)
22531 
      else:
22532 
        iprot.skip(ftype)
22533 
      iprot.readFieldEnd()
22534 
    iprot.readStructEnd()
22535 
 
22536 
  def write(self, oprot):
22537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22539 
      return
22540 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
22541 
    if self.amazonlisted is not None:
22542 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
22543 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 22544 
      for kiter488,viter489 in self.amazonlisted.items():
22545 
        oprot.writeI64(kiter488)
22546 
        viter489.write(oprot)
8168 kshitij.so 22547 
      oprot.writeMapEnd()
22548 
      oprot.writeFieldEnd()
22549 
    oprot.writeFieldStop()
22550 
    oprot.writeStructEnd()
22551 
 
22552 
  def validate(self):
22553 
    return
22554 
 
22555 
 
22556 
  def __repr__(self):
22557 
    L = ['%s=%r' % (key, value)
22558 
      for key, value in self.__dict__.iteritems()]
22559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22560 
 
22561 
  def __eq__(self, other):
22562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22563 
 
22564 
  def __ne__(self, other):
22565 
    return not (self == other)
22566 
 
22567 
class updateAmazonAttributesInBulk_result:
22568 
  """
22569 
  Attributes:
22570 
   - success
22571 
  """
22572 
 
22573 
  thrift_spec = (
22574 
    (0, TType.BOOL, 'success', None, None, ), # 0
22575 
  )
22576 
 
22577 
  def __init__(self, success=None,):
22578 
    self.success = success
22579 
 
22580 
  def read(self, iprot):
22581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22583 
      return
22584 
    iprot.readStructBegin()
22585 
    while True:
22586 
      (fname, ftype, fid) = iprot.readFieldBegin()
22587 
      if ftype == TType.STOP:
22588 
        break
22589 
      if fid == 0:
22590 
        if ftype == TType.BOOL:
22591 
          self.success = iprot.readBool();
22592 
        else:
22593 
          iprot.skip(ftype)
22594 
      else:
22595 
        iprot.skip(ftype)
22596 
      iprot.readFieldEnd()
22597 
    iprot.readStructEnd()
22598 
 
22599 
  def write(self, oprot):
22600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22602 
      return
22603 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
22604 
    if self.success is not None:
22605 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22606 
      oprot.writeBool(self.success)
22607 
      oprot.writeFieldEnd()
22608 
    oprot.writeFieldStop()
22609 
    oprot.writeStructEnd()
22610 
 
22611 
  def validate(self):
22612 
    return
22613 
 
22614 
 
22615 
  def __repr__(self):
22616 
    L = ['%s=%r' % (key, value)
22617 
      for key, value in self.__dict__.iteritems()]
22618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22619 
 
22620 
  def __eq__(self, other):
22621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22622 
 
22623 
  def __ne__(self, other):
22624 
    return not (self == other)
8379 vikram.rag 22625 
 
22626 
class getAllItemstoListOnFba_args:
22627 
 
22628 
  thrift_spec = (
22629 
  )
22630 
 
22631 
  def read(self, iprot):
22632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22634 
      return
22635 
    iprot.readStructBegin()
22636 
    while True:
22637 
      (fname, ftype, fid) = iprot.readFieldBegin()
22638 
      if ftype == TType.STOP:
22639 
        break
22640 
      else:
22641 
        iprot.skip(ftype)
22642 
      iprot.readFieldEnd()
22643 
    iprot.readStructEnd()
22644 
 
22645 
  def write(self, oprot):
22646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22648 
      return
22649 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
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 getAllItemstoListOnFba_result:
22669 
  """
22670 
  Attributes:
22671 
   - success
22672 
  """
22673 
 
22674 
  thrift_spec = (
22675 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22676 
  )
22677 
 
22678 
  def __init__(self, success=None,):
22679 
    self.success = success
22680 
 
22681 
  def read(self, iprot):
22682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22684 
      return
22685 
    iprot.readStructBegin()
22686 
    while True:
22687 
      (fname, ftype, fid) = iprot.readFieldBegin()
22688 
      if ftype == TType.STOP:
22689 
        break
22690 
      if fid == 0:
22691 
        if ftype == TType.LIST:
22692 
          self.success = []
9155 kshitij.so 22693 
          (_etype493, _size490) = iprot.readListBegin()
22694 
          for _i494 in xrange(_size490):
22695 
            _elem495 = Amazonlisted()
22696 
            _elem495.read(iprot)
22697 
            self.success.append(_elem495)
8379 vikram.rag 22698 
          iprot.readListEnd()
22699 
        else:
22700 
          iprot.skip(ftype)
22701 
      else:
22702 
        iprot.skip(ftype)
22703 
      iprot.readFieldEnd()
22704 
    iprot.readStructEnd()
22705 
 
22706 
  def write(self, oprot):
22707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22709 
      return
22710 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
22711 
    if self.success is not None:
22712 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22713 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22714 
      for iter496 in self.success:
22715 
        iter496.write(oprot)
8379 vikram.rag 22716 
      oprot.writeListEnd()
22717 
      oprot.writeFieldEnd()
22718 
    oprot.writeFieldStop()
22719 
    oprot.writeStructEnd()
22720 
 
22721 
  def validate(self):
22722 
    return
22723 
 
22724 
 
22725 
  def __repr__(self):
22726 
    L = ['%s=%r' % (key, value)
22727 
      for key, value in self.__dict__.iteritems()]
22728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22729 
 
22730 
  def __eq__(self, other):
22731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22732 
 
22733 
  def __ne__(self, other):
22734 
    return not (self == other)
22735 
 
22736 
class getAllItemstoListOnNonFba_args:
22737 
 
22738 
  thrift_spec = (
22739 
  )
22740 
 
22741 
  def read(self, iprot):
22742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22744 
      return
22745 
    iprot.readStructBegin()
22746 
    while True:
22747 
      (fname, ftype, fid) = iprot.readFieldBegin()
22748 
      if ftype == TType.STOP:
22749 
        break
22750 
      else:
22751 
        iprot.skip(ftype)
22752 
      iprot.readFieldEnd()
22753 
    iprot.readStructEnd()
22754 
 
22755 
  def write(self, oprot):
22756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22758 
      return
22759 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
22760 
    oprot.writeFieldStop()
22761 
    oprot.writeStructEnd()
22762 
 
22763 
  def validate(self):
22764 
    return
22765 
 
22766 
 
22767 
  def __repr__(self):
22768 
    L = ['%s=%r' % (key, value)
22769 
      for key, value in self.__dict__.iteritems()]
22770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22771 
 
22772 
  def __eq__(self, other):
22773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22774 
 
22775 
  def __ne__(self, other):
22776 
    return not (self == other)
22777 
 
22778 
class getAllItemstoListOnNonFba_result:
22779 
  """
22780 
  Attributes:
22781 
   - success
22782 
  """
22783 
 
22784 
  thrift_spec = (
22785 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22786 
  )
22787 
 
22788 
  def __init__(self, success=None,):
22789 
    self.success = success
22790 
 
22791 
  def read(self, iprot):
22792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22794 
      return
22795 
    iprot.readStructBegin()
22796 
    while True:
22797 
      (fname, ftype, fid) = iprot.readFieldBegin()
22798 
      if ftype == TType.STOP:
22799 
        break
22800 
      if fid == 0:
22801 
        if ftype == TType.LIST:
22802 
          self.success = []
9155 kshitij.so 22803 
          (_etype500, _size497) = iprot.readListBegin()
22804 
          for _i501 in xrange(_size497):
22805 
            _elem502 = Amazonlisted()
22806 
            _elem502.read(iprot)
22807 
            self.success.append(_elem502)
8379 vikram.rag 22808 
          iprot.readListEnd()
22809 
        else:
22810 
          iprot.skip(ftype)
22811 
      else:
22812 
        iprot.skip(ftype)
22813 
      iprot.readFieldEnd()
22814 
    iprot.readStructEnd()
22815 
 
22816 
  def write(self, oprot):
22817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22819 
      return
22820 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
22821 
    if self.success is not None:
22822 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22823 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22824 
      for iter503 in self.success:
22825 
        iter503.write(oprot)
8379 vikram.rag 22826 
      oprot.writeListEnd()
22827 
      oprot.writeFieldEnd()
22828 
    oprot.writeFieldStop()
22829 
    oprot.writeStructEnd()
22830 
 
22831 
  def validate(self):
22832 
    return
22833 
 
22834 
 
22835 
  def __repr__(self):
22836 
    L = ['%s=%r' % (key, value)
22837 
      for key, value in self.__dict__.iteritems()]
22838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22839 
 
22840 
  def __eq__(self, other):
22841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22842 
 
22843 
  def __ne__(self, other):
22844 
    return not (self == other)
8616 vikram.rag 22845 
 
9242 kshitij.so 22846 
class updateAsin_args:
22847 
  """
22848 
  Attributes:
22849 
   - item
22850 
  """
8616 vikram.rag 22851 
 
22852 
  thrift_spec = (
9242 kshitij.so 22853 
    None, # 0
22854 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 22855 
  )
22856 
 
9242 kshitij.so 22857 
  def __init__(self, item=None,):
22858 
    self.item = item
22859 
 
8616 vikram.rag 22860 
  def read(self, iprot):
22861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22863 
      return
22864 
    iprot.readStructBegin()
22865 
    while True:
22866 
      (fname, ftype, fid) = iprot.readFieldBegin()
22867 
      if ftype == TType.STOP:
22868 
        break
9242 kshitij.so 22869 
      if fid == 1:
22870 
        if ftype == TType.MAP:
22871 
          self.item = {}
22872 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
22873 
          for _i508 in xrange(_size504):
22874 
            _key509 = iprot.readI64();
22875 
            _val510 = Item()
22876 
            _val510.read(iprot)
22877 
            self.item[_key509] = _val510
22878 
          iprot.readMapEnd()
22879 
        else:
22880 
          iprot.skip(ftype)
8616 vikram.rag 22881 
      else:
22882 
        iprot.skip(ftype)
22883 
      iprot.readFieldEnd()
22884 
    iprot.readStructEnd()
22885 
 
22886 
  def write(self, oprot):
22887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22889 
      return
9242 kshitij.so 22890 
    oprot.writeStructBegin('updateAsin_args')
22891 
    if self.item is not None:
22892 
      oprot.writeFieldBegin('item', TType.MAP, 1)
22893 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
22894 
      for kiter511,viter512 in self.item.items():
22895 
        oprot.writeI64(kiter511)
22896 
        viter512.write(oprot)
22897 
      oprot.writeMapEnd()
22898 
      oprot.writeFieldEnd()
8616 vikram.rag 22899 
    oprot.writeFieldStop()
22900 
    oprot.writeStructEnd()
22901 
 
22902 
  def validate(self):
22903 
    return
22904 
 
22905 
 
22906 
  def __repr__(self):
22907 
    L = ['%s=%r' % (key, value)
22908 
      for key, value in self.__dict__.iteritems()]
22909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22910 
 
22911 
  def __eq__(self, other):
22912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22913 
 
22914 
  def __ne__(self, other):
22915 
    return not (self == other)
22916 
 
9242 kshitij.so 22917 
class updateAsin_result:
8616 vikram.rag 22918 
 
22919 
  thrift_spec = (
22920 
  )
22921 
 
22922 
  def read(self, iprot):
22923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22925 
      return
22926 
    iprot.readStructBegin()
22927 
    while True:
22928 
      (fname, ftype, fid) = iprot.readFieldBegin()
22929 
      if ftype == TType.STOP:
22930 
        break
22931 
      else:
22932 
        iprot.skip(ftype)
22933 
      iprot.readFieldEnd()
22934 
    iprot.readStructEnd()
22935 
 
22936 
  def write(self, oprot):
22937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22939 
      return
9242 kshitij.so 22940 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 22941 
    oprot.writeFieldStop()
22942 
    oprot.writeStructEnd()
22943 
 
22944 
  def validate(self):
22945 
    return
22946 
 
22947 
 
22948 
  def __repr__(self):
22949 
    L = ['%s=%r' % (key, value)
22950 
      for key, value in self.__dict__.iteritems()]
22951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22952 
 
22953 
  def __eq__(self, other):
22954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22955 
 
22956 
  def __ne__(self, other):
22957 
    return not (self == other)
8619 kshitij.so 22958 
 
9242 kshitij.so 22959 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 22960 
  """
22961 
  Attributes:
9242 kshitij.so 22962 
   - snapdealitem
8619 kshitij.so 22963 
  """
22964 
 
9242 kshitij.so 22965 
  thrift_spec = None
22966 
  def __init__(self, snapdealitem=None,):
22967 
    self.snapdealitem = snapdealitem
8619 kshitij.so 22968 
 
22969 
  def read(self, iprot):
22970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22972 
      return
22973 
    iprot.readStructBegin()
22974 
    while True:
22975 
      (fname, ftype, fid) = iprot.readFieldBegin()
22976 
      if ftype == TType.STOP:
22977 
        break
9242 kshitij.so 22978 
      if fid == -1:
22979 
        if ftype == TType.STRUCT:
22980 
          self.snapdealitem = SnapdealItem()
22981 
          self.snapdealitem.read(iprot)
8619 kshitij.so 22982 
        else:
22983 
          iprot.skip(ftype)
22984 
      else:
22985 
        iprot.skip(ftype)
22986 
      iprot.readFieldEnd()
22987 
    iprot.readStructEnd()
22988 
 
22989 
  def write(self, oprot):
22990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22992 
      return
9242 kshitij.so 22993 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
22994 
    if self.snapdealitem is not None:
22995 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
22996 
      self.snapdealitem.write(oprot)
8619 kshitij.so 22997 
      oprot.writeFieldEnd()
22998 
    oprot.writeFieldStop()
22999 
    oprot.writeStructEnd()
23000 
 
23001 
  def validate(self):
23002 
    return
23003 
 
23004 
 
23005 
  def __repr__(self):
23006 
    L = ['%s=%r' % (key, value)
23007 
      for key, value in self.__dict__.iteritems()]
23008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23009 
 
23010 
  def __eq__(self, other):
23011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23012 
 
23013 
  def __ne__(self, other):
23014 
    return not (self == other)
23015 
 
9242 kshitij.so 23016 
class addOrUpdateSnapdealItem_result:
23017 
  """
23018 
  Attributes:
23019 
   - success
23020 
  """
8619 kshitij.so 23021 
 
23022 
  thrift_spec = (
9242 kshitij.so 23023 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 23024 
  )
23025 
 
9242 kshitij.so 23026 
  def __init__(self, success=None,):
23027 
    self.success = success
23028 
 
8619 kshitij.so 23029 
  def read(self, iprot):
23030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23032 
      return
23033 
    iprot.readStructBegin()
23034 
    while True:
23035 
      (fname, ftype, fid) = iprot.readFieldBegin()
23036 
      if ftype == TType.STOP:
23037 
        break
9242 kshitij.so 23038 
      if fid == 0:
23039 
        if ftype == TType.BOOL:
23040 
          self.success = iprot.readBool();
23041 
        else:
23042 
          iprot.skip(ftype)
8619 kshitij.so 23043 
      else:
23044 
        iprot.skip(ftype)
23045 
      iprot.readFieldEnd()
23046 
    iprot.readStructEnd()
23047 
 
23048 
  def write(self, oprot):
23049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23051 
      return
9242 kshitij.so 23052 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
23053 
    if self.success is not None:
23054 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23055 
      oprot.writeBool(self.success)
23056 
      oprot.writeFieldEnd()
8619 kshitij.so 23057 
    oprot.writeFieldStop()
23058 
    oprot.writeStructEnd()
23059 
 
23060 
  def validate(self):
23061 
    return
23062 
 
23063 
 
23064 
  def __repr__(self):
23065 
    L = ['%s=%r' % (key, value)
23066 
      for key, value in self.__dict__.iteritems()]
23067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23068 
 
23069 
  def __eq__(self, other):
23070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23071 
 
23072 
  def __ne__(self, other):
23073 
    return not (self == other)
8739 vikram.rag 23074 
 
9242 kshitij.so 23075 
class getSnapdealItem_args:
8739 vikram.rag 23076 
  """
23077 
  Attributes:
9242 kshitij.so 23078 
   - item_id
8739 vikram.rag 23079 
  """
23080 
 
9242 kshitij.so 23081 
  thrift_spec = (
23082 
    None, # 0
23083 
    (1, TType.I64, 'item_id', None, None, ), # 1
23084 
  )
8739 vikram.rag 23085 
 
9242 kshitij.so 23086 
  def __init__(self, item_id=None,):
23087 
    self.item_id = item_id
23088 
 
8739 vikram.rag 23089 
  def read(self, iprot):
23090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23092 
      return
23093 
    iprot.readStructBegin()
23094 
    while True:
23095 
      (fname, ftype, fid) = iprot.readFieldBegin()
23096 
      if ftype == TType.STOP:
23097 
        break
9242 kshitij.so 23098 
      if fid == 1:
23099 
        if ftype == TType.I64:
23100 
          self.item_id = iprot.readI64();
8739 vikram.rag 23101 
        else:
23102 
          iprot.skip(ftype)
23103 
      else:
23104 
        iprot.skip(ftype)
23105 
      iprot.readFieldEnd()
23106 
    iprot.readStructEnd()
23107 
 
23108 
  def write(self, oprot):
23109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23111 
      return
9242 kshitij.so 23112 
    oprot.writeStructBegin('getSnapdealItem_args')
23113 
    if self.item_id is not None:
23114 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23115 
      oprot.writeI64(self.item_id)
8739 vikram.rag 23116 
      oprot.writeFieldEnd()
23117 
    oprot.writeFieldStop()
23118 
    oprot.writeStructEnd()
23119 
 
23120 
  def validate(self):
23121 
    return
23122 
 
23123 
 
23124 
  def __repr__(self):
23125 
    L = ['%s=%r' % (key, value)
23126 
      for key, value in self.__dict__.iteritems()]
23127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23128 
 
23129 
  def __eq__(self, other):
23130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23131 
 
23132 
  def __ne__(self, other):
23133 
    return not (self == other)
23134 
 
9242 kshitij.so 23135 
class getSnapdealItem_result:
8739 vikram.rag 23136 
  """
23137 
  Attributes:
23138 
   - success
23139 
  """
23140 
 
23141 
  thrift_spec = (
9242 kshitij.so 23142 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 23143 
  )
23144 
 
23145 
  def __init__(self, success=None,):
23146 
    self.success = success
23147 
 
23148 
  def read(self, iprot):
23149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23151 
      return
23152 
    iprot.readStructBegin()
23153 
    while True:
23154 
      (fname, ftype, fid) = iprot.readFieldBegin()
23155 
      if ftype == TType.STOP:
23156 
        break
23157 
      if fid == 0:
9242 kshitij.so 23158 
        if ftype == TType.STRUCT:
23159 
          self.success = SnapdealItem()
23160 
          self.success.read(iprot)
8739 vikram.rag 23161 
        else:
23162 
          iprot.skip(ftype)
23163 
      else:
23164 
        iprot.skip(ftype)
23165 
      iprot.readFieldEnd()
23166 
    iprot.readStructEnd()
23167 
 
23168 
  def write(self, oprot):
23169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23171 
      return
9242 kshitij.so 23172 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 23173 
    if self.success is not None:
9242 kshitij.so 23174 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23175 
      self.success.write(oprot)
8739 vikram.rag 23176 
      oprot.writeFieldEnd()
23177 
    oprot.writeFieldStop()
23178 
    oprot.writeStructEnd()
23179 
 
23180 
  def validate(self):
23181 
    return
23182 
 
23183 
 
23184 
  def __repr__(self):
23185 
    L = ['%s=%r' % (key, value)
23186 
      for key, value in self.__dict__.iteritems()]
23187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23188 
 
23189 
  def __eq__(self, other):
23190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23191 
 
23192 
  def __ne__(self, other):
23193 
    return not (self == other)
23194 
 
9242 kshitij.so 23195 
class getSnapdealItemDetails_args:
8739 vikram.rag 23196 
  """
23197 
  Attributes:
23198 
   - item_id
23199 
  """
23200 
 
23201 
  thrift_spec = (
23202 
    None, # 0
23203 
    (1, TType.I64, 'item_id', None, None, ), # 1
23204 
  )
23205 
 
23206 
  def __init__(self, item_id=None,):
23207 
    self.item_id = item_id
23208 
 
23209 
  def read(self, iprot):
23210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23212 
      return
23213 
    iprot.readStructBegin()
23214 
    while True:
23215 
      (fname, ftype, fid) = iprot.readFieldBegin()
23216 
      if ftype == TType.STOP:
23217 
        break
23218 
      if fid == 1:
23219 
        if ftype == TType.I64:
23220 
          self.item_id = iprot.readI64();
23221 
        else:
23222 
          iprot.skip(ftype)
23223 
      else:
23224 
        iprot.skip(ftype)
23225 
      iprot.readFieldEnd()
23226 
    iprot.readStructEnd()
23227 
 
23228 
  def write(self, oprot):
23229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23231 
      return
9242 kshitij.so 23232 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 23233 
    if self.item_id is not None:
23234 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23235 
      oprot.writeI64(self.item_id)
23236 
      oprot.writeFieldEnd()
23237 
    oprot.writeFieldStop()
23238 
    oprot.writeStructEnd()
23239 
 
23240 
  def validate(self):
23241 
    return
23242 
 
23243 
 
23244 
  def __repr__(self):
23245 
    L = ['%s=%r' % (key, value)
23246 
      for key, value in self.__dict__.iteritems()]
23247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23248 
 
23249 
  def __eq__(self, other):
23250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23251 
 
23252 
  def __ne__(self, other):
23253 
    return not (self == other)
23254 
 
9242 kshitij.so 23255 
class getSnapdealItemDetails_result:
8739 vikram.rag 23256 
  """
23257 
  Attributes:
23258 
   - success
23259 
  """
23260 
 
23261 
  thrift_spec = (
9242 kshitij.so 23262 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 23263 
  )
23264 
 
23265 
  def __init__(self, success=None,):
23266 
    self.success = success
23267 
 
23268 
  def read(self, iprot):
23269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23271 
      return
23272 
    iprot.readStructBegin()
23273 
    while True:
23274 
      (fname, ftype, fid) = iprot.readFieldBegin()
23275 
      if ftype == TType.STOP:
23276 
        break
23277 
      if fid == 0:
23278 
        if ftype == TType.STRUCT:
9242 kshitij.so 23279 
          self.success = SnapdealItemDetails()
8739 vikram.rag 23280 
          self.success.read(iprot)
23281 
        else:
23282 
          iprot.skip(ftype)
23283 
      else:
23284 
        iprot.skip(ftype)
23285 
      iprot.readFieldEnd()
23286 
    iprot.readStructEnd()
23287 
 
23288 
  def write(self, oprot):
23289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23291 
      return
9242 kshitij.so 23292 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 23293 
    if self.success is not None:
23294 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23295 
      self.success.write(oprot)
23296 
      oprot.writeFieldEnd()
23297 
    oprot.writeFieldStop()
23298 
    oprot.writeStructEnd()
23299 
 
23300 
  def validate(self):
23301 
    return
23302 
 
23303 
 
23304 
  def __repr__(self):
23305 
    L = ['%s=%r' % (key, value)
23306 
      for key, value in self.__dict__.iteritems()]
23307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23308 
 
23309 
  def __eq__(self, other):
23310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23311 
 
23312 
  def __ne__(self, other):
23313 
    return not (self == other)
23314 
 
23315 
class getAllSnapdealItems_args:
23316 
 
23317 
  thrift_spec = (
23318 
  )
23319 
 
23320 
  def read(self, iprot):
23321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23323 
      return
23324 
    iprot.readStructBegin()
23325 
    while True:
23326 
      (fname, ftype, fid) = iprot.readFieldBegin()
23327 
      if ftype == TType.STOP:
23328 
        break
23329 
      else:
23330 
        iprot.skip(ftype)
23331 
      iprot.readFieldEnd()
23332 
    iprot.readStructEnd()
23333 
 
23334 
  def write(self, oprot):
23335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23337 
      return
23338 
    oprot.writeStructBegin('getAllSnapdealItems_args')
23339 
    oprot.writeFieldStop()
23340 
    oprot.writeStructEnd()
23341 
 
23342 
  def validate(self):
23343 
    return
23344 
 
23345 
 
23346 
  def __repr__(self):
23347 
    L = ['%s=%r' % (key, value)
23348 
      for key, value in self.__dict__.iteritems()]
23349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23350 
 
23351 
  def __eq__(self, other):
23352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23353 
 
23354 
  def __ne__(self, other):
23355 
    return not (self == other)
23356 
 
23357 
class getAllSnapdealItems_result:
23358 
  """
23359 
  Attributes:
23360 
   - success
23361 
  """
23362 
 
23363 
  thrift_spec = (
9242 kshitij.so 23364 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 23365 
  )
23366 
 
23367 
  def __init__(self, success=None,):
23368 
    self.success = success
23369 
 
23370 
  def read(self, iprot):
23371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23373 
      return
23374 
    iprot.readStructBegin()
23375 
    while True:
23376 
      (fname, ftype, fid) = iprot.readFieldBegin()
23377 
      if ftype == TType.STOP:
23378 
        break
23379 
      if fid == 0:
23380 
        if ftype == TType.LIST:
23381 
          self.success = []
9242 kshitij.so 23382 
          (_etype516, _size513) = iprot.readListBegin()
23383 
          for _i517 in xrange(_size513):
23384 
            _elem518 = SnapdealItemDetails()
23385 
            _elem518.read(iprot)
23386 
            self.success.append(_elem518)
23387 
          iprot.readListEnd()
23388 
        else:
23389 
          iprot.skip(ftype)
23390 
      else:
23391 
        iprot.skip(ftype)
23392 
      iprot.readFieldEnd()
23393 
    iprot.readStructEnd()
23394 
 
23395 
  def write(self, oprot):
23396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23398 
      return
23399 
    oprot.writeStructBegin('getAllSnapdealItems_result')
23400 
    if self.success is not None:
23401 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23402 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23403 
      for iter519 in self.success:
23404 
        iter519.write(oprot)
23405 
      oprot.writeListEnd()
23406 
      oprot.writeFieldEnd()
23407 
    oprot.writeFieldStop()
23408 
    oprot.writeStructEnd()
23409 
 
23410 
  def validate(self):
23411 
    return
23412 
 
23413 
 
23414 
  def __repr__(self):
23415 
    L = ['%s=%r' % (key, value)
23416 
      for key, value in self.__dict__.iteritems()]
23417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23418 
 
23419 
  def __eq__(self, other):
23420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23421 
 
23422 
  def __ne__(self, other):
23423 
    return not (self == other)
23424 
 
23425 
class getSnapdealItems_args:
23426 
  """
23427 
  Attributes:
23428 
   - offset
23429 
   - limit
23430 
  """
23431 
 
23432 
  thrift_spec = (
23433 
    None, # 0
23434 
    (1, TType.I64, 'offset', None, None, ), # 1
23435 
    (2, TType.I64, 'limit', None, None, ), # 2
23436 
  )
23437 
 
23438 
  def __init__(self, offset=None, limit=None,):
23439 
    self.offset = offset
23440 
    self.limit = limit
23441 
 
23442 
  def read(self, iprot):
23443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23445 
      return
23446 
    iprot.readStructBegin()
23447 
    while True:
23448 
      (fname, ftype, fid) = iprot.readFieldBegin()
23449 
      if ftype == TType.STOP:
23450 
        break
23451 
      if fid == 1:
23452 
        if ftype == TType.I64:
23453 
          self.offset = iprot.readI64();
23454 
        else:
23455 
          iprot.skip(ftype)
23456 
      elif fid == 2:
23457 
        if ftype == TType.I64:
23458 
          self.limit = iprot.readI64();
23459 
        else:
23460 
          iprot.skip(ftype)
23461 
      else:
23462 
        iprot.skip(ftype)
23463 
      iprot.readFieldEnd()
23464 
    iprot.readStructEnd()
23465 
 
23466 
  def write(self, oprot):
23467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23469 
      return
23470 
    oprot.writeStructBegin('getSnapdealItems_args')
23471 
    if self.offset is not None:
23472 
      oprot.writeFieldBegin('offset', TType.I64, 1)
23473 
      oprot.writeI64(self.offset)
23474 
      oprot.writeFieldEnd()
23475 
    if self.limit is not None:
23476 
      oprot.writeFieldBegin('limit', TType.I64, 2)
23477 
      oprot.writeI64(self.limit)
23478 
      oprot.writeFieldEnd()
23479 
    oprot.writeFieldStop()
23480 
    oprot.writeStructEnd()
23481 
 
23482 
  def validate(self):
23483 
    return
23484 
 
23485 
 
23486 
  def __repr__(self):
23487 
    L = ['%s=%r' % (key, value)
23488 
      for key, value in self.__dict__.iteritems()]
23489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23490 
 
23491 
  def __eq__(self, other):
23492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23493 
 
23494 
  def __ne__(self, other):
23495 
    return not (self == other)
23496 
 
23497 
class getSnapdealItems_result:
23498 
  """
23499 
  Attributes:
23500 
   - success
23501 
  """
23502 
 
23503 
  thrift_spec = (
23504 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23505 
  )
23506 
 
23507 
  def __init__(self, success=None,):
23508 
    self.success = success
23509 
 
23510 
  def read(self, iprot):
23511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23513 
      return
23514 
    iprot.readStructBegin()
23515 
    while True:
23516 
      (fname, ftype, fid) = iprot.readFieldBegin()
23517 
      if ftype == TType.STOP:
23518 
        break
23519 
      if fid == 0:
23520 
        if ftype == TType.LIST:
23521 
          self.success = []
9155 kshitij.so 23522 
          (_etype523, _size520) = iprot.readListBegin()
23523 
          for _i524 in xrange(_size520):
9242 kshitij.so 23524 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 23525 
            _elem525.read(iprot)
23526 
            self.success.append(_elem525)
8739 vikram.rag 23527 
          iprot.readListEnd()
23528 
        else:
23529 
          iprot.skip(ftype)
23530 
      else:
23531 
        iprot.skip(ftype)
23532 
      iprot.readFieldEnd()
23533 
    iprot.readStructEnd()
23534 
 
23535 
  def write(self, oprot):
23536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23538 
      return
9242 kshitij.so 23539 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 23540 
    if self.success is not None:
23541 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23542 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23543 
      for iter526 in self.success:
23544 
        iter526.write(oprot)
8739 vikram.rag 23545 
      oprot.writeListEnd()
23546 
      oprot.writeFieldEnd()
23547 
    oprot.writeFieldStop()
23548 
    oprot.writeStructEnd()
23549 
 
23550 
  def validate(self):
23551 
    return
23552 
 
23553 
 
23554 
  def __repr__(self):
23555 
    L = ['%s=%r' % (key, value)
23556 
      for key, value in self.__dict__.iteritems()]
23557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23558 
 
23559 
  def __eq__(self, other):
23560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23561 
 
23562 
  def __ne__(self, other):
23563 
    return not (self == other)
9242 kshitij.so 23564 
 
23565 
class searchSnapdealItems_args:
23566 
  """
23567 
  Attributes:
23568 
   - searchTerm
23569 
   - offset
23570 
   - limit
23571 
  """
23572 
 
23573 
  thrift_spec = (
23574 
    None, # 0
23575 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23576 
    (2, TType.I64, 'offset', None, None, ), # 2
23577 
    (3, TType.I64, 'limit', None, None, ), # 3
23578 
  )
23579 
 
23580 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
23581 
    self.searchTerm = searchTerm
23582 
    self.offset = offset
23583 
    self.limit = limit
23584 
 
23585 
  def read(self, iprot):
23586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23588 
      return
23589 
    iprot.readStructBegin()
23590 
    while True:
23591 
      (fname, ftype, fid) = iprot.readFieldBegin()
23592 
      if ftype == TType.STOP:
23593 
        break
23594 
      if fid == 1:
23595 
        if ftype == TType.LIST:
23596 
          self.searchTerm = []
23597 
          (_etype530, _size527) = iprot.readListBegin()
23598 
          for _i531 in xrange(_size527):
23599 
            _elem532 = iprot.readString();
23600 
            self.searchTerm.append(_elem532)
23601 
          iprot.readListEnd()
23602 
        else:
23603 
          iprot.skip(ftype)
23604 
      elif fid == 2:
23605 
        if ftype == TType.I64:
23606 
          self.offset = iprot.readI64();
23607 
        else:
23608 
          iprot.skip(ftype)
23609 
      elif fid == 3:
23610 
        if ftype == TType.I64:
23611 
          self.limit = iprot.readI64();
23612 
        else:
23613 
          iprot.skip(ftype)
23614 
      else:
23615 
        iprot.skip(ftype)
23616 
      iprot.readFieldEnd()
23617 
    iprot.readStructEnd()
23618 
 
23619 
  def write(self, oprot):
23620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23622 
      return
23623 
    oprot.writeStructBegin('searchSnapdealItems_args')
23624 
    if self.searchTerm is not None:
23625 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23626 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23627 
      for iter533 in self.searchTerm:
23628 
        oprot.writeString(iter533)
23629 
      oprot.writeListEnd()
23630 
      oprot.writeFieldEnd()
23631 
    if self.offset is not None:
23632 
      oprot.writeFieldBegin('offset', TType.I64, 2)
23633 
      oprot.writeI64(self.offset)
23634 
      oprot.writeFieldEnd()
23635 
    if self.limit is not None:
23636 
      oprot.writeFieldBegin('limit', TType.I64, 3)
23637 
      oprot.writeI64(self.limit)
23638 
      oprot.writeFieldEnd()
23639 
    oprot.writeFieldStop()
23640 
    oprot.writeStructEnd()
23641 
 
23642 
  def validate(self):
23643 
    return
23644 
 
23645 
 
23646 
  def __repr__(self):
23647 
    L = ['%s=%r' % (key, value)
23648 
      for key, value in self.__dict__.iteritems()]
23649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23650 
 
23651 
  def __eq__(self, other):
23652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23653 
 
23654 
  def __ne__(self, other):
23655 
    return not (self == other)
23656 
 
23657 
class searchSnapdealItems_result:
23658 
  """
23659 
  Attributes:
23660 
   - success
23661 
  """
23662 
 
23663 
  thrift_spec = (
23664 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23665 
  )
23666 
 
23667 
  def __init__(self, success=None,):
23668 
    self.success = success
23669 
 
23670 
  def read(self, iprot):
23671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23673 
      return
23674 
    iprot.readStructBegin()
23675 
    while True:
23676 
      (fname, ftype, fid) = iprot.readFieldBegin()
23677 
      if ftype == TType.STOP:
23678 
        break
23679 
      if fid == 0:
23680 
        if ftype == TType.LIST:
23681 
          self.success = []
23682 
          (_etype537, _size534) = iprot.readListBegin()
23683 
          for _i538 in xrange(_size534):
23684 
            _elem539 = SnapdealItemDetails()
23685 
            _elem539.read(iprot)
23686 
            self.success.append(_elem539)
23687 
          iprot.readListEnd()
23688 
        else:
23689 
          iprot.skip(ftype)
23690 
      else:
23691 
        iprot.skip(ftype)
23692 
      iprot.readFieldEnd()
23693 
    iprot.readStructEnd()
23694 
 
23695 
  def write(self, oprot):
23696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23698 
      return
23699 
    oprot.writeStructBegin('searchSnapdealItems_result')
23700 
    if self.success is not None:
23701 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23702 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23703 
      for iter540 in self.success:
23704 
        iter540.write(oprot)
23705 
      oprot.writeListEnd()
23706 
      oprot.writeFieldEnd()
23707 
    oprot.writeFieldStop()
23708 
    oprot.writeStructEnd()
23709 
 
23710 
  def validate(self):
23711 
    return
23712 
 
23713 
 
23714 
  def __repr__(self):
23715 
    L = ['%s=%r' % (key, value)
23716 
      for key, value in self.__dict__.iteritems()]
23717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23718 
 
23719 
  def __eq__(self, other):
23720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23721 
 
23722 
  def __ne__(self, other):
23723 
    return not (self == other)
23724 
 
23725 
class getCountForSnapdealItems_args:
23726 
 
23727 
  thrift_spec = (
23728 
  )
23729 
 
23730 
  def read(self, iprot):
23731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23733 
      return
23734 
    iprot.readStructBegin()
23735 
    while True:
23736 
      (fname, ftype, fid) = iprot.readFieldBegin()
23737 
      if ftype == TType.STOP:
23738 
        break
23739 
      else:
23740 
        iprot.skip(ftype)
23741 
      iprot.readFieldEnd()
23742 
    iprot.readStructEnd()
23743 
 
23744 
  def write(self, oprot):
23745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23747 
      return
23748 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
23749 
    oprot.writeFieldStop()
23750 
    oprot.writeStructEnd()
23751 
 
23752 
  def validate(self):
23753 
    return
23754 
 
23755 
 
23756 
  def __repr__(self):
23757 
    L = ['%s=%r' % (key, value)
23758 
      for key, value in self.__dict__.iteritems()]
23759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23760 
 
23761 
  def __eq__(self, other):
23762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23763 
 
23764 
  def __ne__(self, other):
23765 
    return not (self == other)
23766 
 
23767 
class getCountForSnapdealItems_result:
23768 
  """
23769 
  Attributes:
23770 
   - success
23771 
  """
23772 
 
23773 
  thrift_spec = (
23774 
    (0, TType.I64, 'success', None, None, ), # 0
23775 
  )
23776 
 
23777 
  def __init__(self, success=None,):
23778 
    self.success = success
23779 
 
23780 
  def read(self, iprot):
23781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23783 
      return
23784 
    iprot.readStructBegin()
23785 
    while True:
23786 
      (fname, ftype, fid) = iprot.readFieldBegin()
23787 
      if ftype == TType.STOP:
23788 
        break
23789 
      if fid == 0:
23790 
        if ftype == TType.I64:
23791 
          self.success = iprot.readI64();
23792 
        else:
23793 
          iprot.skip(ftype)
23794 
      else:
23795 
        iprot.skip(ftype)
23796 
      iprot.readFieldEnd()
23797 
    iprot.readStructEnd()
23798 
 
23799 
  def write(self, oprot):
23800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23802 
      return
23803 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
23804 
    if self.success is not None:
23805 
      oprot.writeFieldBegin('success', TType.I64, 0)
23806 
      oprot.writeI64(self.success)
23807 
      oprot.writeFieldEnd()
23808 
    oprot.writeFieldStop()
23809 
    oprot.writeStructEnd()
23810 
 
23811 
  def validate(self):
23812 
    return
23813 
 
23814 
 
23815 
  def __repr__(self):
23816 
    L = ['%s=%r' % (key, value)
23817 
      for key, value in self.__dict__.iteritems()]
23818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23819 
 
23820 
  def __eq__(self, other):
23821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23822 
 
23823 
  def __ne__(self, other):
23824 
    return not (self == other)
23825 
 
23826 
class getSnapdealSearchResultCount_args:
23827 
  """
23828 
  Attributes:
23829 
   - searchTerm
23830 
  """
23831 
 
23832 
  thrift_spec = (
23833 
    None, # 0
23834 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23835 
  )
23836 
 
23837 
  def __init__(self, searchTerm=None,):
23838 
    self.searchTerm = searchTerm
23839 
 
23840 
  def read(self, iprot):
23841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23843 
      return
23844 
    iprot.readStructBegin()
23845 
    while True:
23846 
      (fname, ftype, fid) = iprot.readFieldBegin()
23847 
      if ftype == TType.STOP:
23848 
        break
23849 
      if fid == 1:
23850 
        if ftype == TType.LIST:
23851 
          self.searchTerm = []
23852 
          (_etype544, _size541) = iprot.readListBegin()
23853 
          for _i545 in xrange(_size541):
23854 
            _elem546 = iprot.readString();
23855 
            self.searchTerm.append(_elem546)
23856 
          iprot.readListEnd()
23857 
        else:
23858 
          iprot.skip(ftype)
23859 
      else:
23860 
        iprot.skip(ftype)
23861 
      iprot.readFieldEnd()
23862 
    iprot.readStructEnd()
23863 
 
23864 
  def write(self, oprot):
23865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23867 
      return
23868 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
23869 
    if self.searchTerm is not None:
23870 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23871 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23872 
      for iter547 in self.searchTerm:
23873 
        oprot.writeString(iter547)
23874 
      oprot.writeListEnd()
23875 
      oprot.writeFieldEnd()
23876 
    oprot.writeFieldStop()
23877 
    oprot.writeStructEnd()
23878 
 
23879 
  def validate(self):
23880 
    return
23881 
 
23882 
 
23883 
  def __repr__(self):
23884 
    L = ['%s=%r' % (key, value)
23885 
      for key, value in self.__dict__.iteritems()]
23886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23887 
 
23888 
  def __eq__(self, other):
23889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23890 
 
23891 
  def __ne__(self, other):
23892 
    return not (self == other)
23893 
 
23894 
class getSnapdealSearchResultCount_result:
23895 
  """
23896 
  Attributes:
23897 
   - success
23898 
  """
23899 
 
23900 
  thrift_spec = (
23901 
    (0, TType.I64, 'success', None, None, ), # 0
23902 
  )
23903 
 
23904 
  def __init__(self, success=None,):
23905 
    self.success = success
23906 
 
23907 
  def read(self, iprot):
23908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23910 
      return
23911 
    iprot.readStructBegin()
23912 
    while True:
23913 
      (fname, ftype, fid) = iprot.readFieldBegin()
23914 
      if ftype == TType.STOP:
23915 
        break
23916 
      if fid == 0:
23917 
        if ftype == TType.I64:
23918 
          self.success = iprot.readI64();
23919 
        else:
23920 
          iprot.skip(ftype)
23921 
      else:
23922 
        iprot.skip(ftype)
23923 
      iprot.readFieldEnd()
23924 
    iprot.readStructEnd()
23925 
 
23926 
  def write(self, oprot):
23927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23929 
      return
23930 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
23931 
    if self.success is not None:
23932 
      oprot.writeFieldBegin('success', TType.I64, 0)
23933 
      oprot.writeI64(self.success)
23934 
      oprot.writeFieldEnd()
23935 
    oprot.writeFieldStop()
23936 
    oprot.writeStructEnd()
23937 
 
23938 
  def validate(self):
23939 
    return
23940 
 
23941 
 
23942 
  def __repr__(self):
23943 
    L = ['%s=%r' % (key, value)
23944 
      for key, value in self.__dict__.iteritems()]
23945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23946 
 
23947 
  def __eq__(self, other):
23948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23949 
 
23950 
  def __ne__(self, other):
23951 
    return not (self == other)
9299 kshitij.so 23952 
 
23953 
class getPrefferedInsurerForItem_args:
23954 
  """
23955 
  Attributes:
23956 
   - itemId
23957 
   - insurerType
23958 
  """
23959 
 
23960 
  thrift_spec = (
23961 
    None, # 0
23962 
    (1, TType.I64, 'itemId', None, None, ), # 1
23963 
    (2, TType.I32, 'insurerType', None, None, ), # 2
23964 
  )
23965 
 
23966 
  def __init__(self, itemId=None, insurerType=None,):
23967 
    self.itemId = itemId
23968 
    self.insurerType = insurerType
23969 
 
23970 
  def read(self, iprot):
23971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23973 
      return
23974 
    iprot.readStructBegin()
23975 
    while True:
23976 
      (fname, ftype, fid) = iprot.readFieldBegin()
23977 
      if ftype == TType.STOP:
23978 
        break
23979 
      if fid == 1:
23980 
        if ftype == TType.I64:
23981 
          self.itemId = iprot.readI64();
23982 
        else:
23983 
          iprot.skip(ftype)
23984 
      elif fid == 2:
23985 
        if ftype == TType.I32:
23986 
          self.insurerType = iprot.readI32();
23987 
        else:
23988 
          iprot.skip(ftype)
23989 
      else:
23990 
        iprot.skip(ftype)
23991 
      iprot.readFieldEnd()
23992 
    iprot.readStructEnd()
23993 
 
23994 
  def write(self, oprot):
23995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23997 
      return
23998 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
23999 
    if self.itemId is not None:
24000 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24001 
      oprot.writeI64(self.itemId)
24002 
      oprot.writeFieldEnd()
24003 
    if self.insurerType is not None:
24004 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
24005 
      oprot.writeI32(self.insurerType)
24006 
      oprot.writeFieldEnd()
24007 
    oprot.writeFieldStop()
24008 
    oprot.writeStructEnd()
24009 
 
24010 
  def validate(self):
24011 
    return
24012 
 
24013 
 
24014 
  def __repr__(self):
24015 
    L = ['%s=%r' % (key, value)
24016 
      for key, value in self.__dict__.iteritems()]
24017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24018 
 
24019 
  def __eq__(self, other):
24020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24021 
 
24022 
  def __ne__(self, other):
24023 
    return not (self == other)
24024 
 
24025 
class getPrefferedInsurerForItem_result:
24026 
  """
24027 
  Attributes:
24028 
   - success
24029 
  """
24030 
 
24031 
  thrift_spec = (
24032 
    (0, TType.I64, 'success', None, None, ), # 0
24033 
  )
24034 
 
24035 
  def __init__(self, success=None,):
24036 
    self.success = success
24037 
 
24038 
  def read(self, iprot):
24039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24041 
      return
24042 
    iprot.readStructBegin()
24043 
    while True:
24044 
      (fname, ftype, fid) = iprot.readFieldBegin()
24045 
      if ftype == TType.STOP:
24046 
        break
24047 
      if fid == 0:
24048 
        if ftype == TType.I64:
24049 
          self.success = iprot.readI64();
24050 
        else:
24051 
          iprot.skip(ftype)
24052 
      else:
24053 
        iprot.skip(ftype)
24054 
      iprot.readFieldEnd()
24055 
    iprot.readStructEnd()
24056 
 
24057 
  def write(self, oprot):
24058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24060 
      return
24061 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
24062 
    if self.success is not None:
24063 
      oprot.writeFieldBegin('success', TType.I64, 0)
24064 
      oprot.writeI64(self.success)
24065 
      oprot.writeFieldEnd()
24066 
    oprot.writeFieldStop()
24067 
    oprot.writeStructEnd()
24068 
 
24069 
  def validate(self):
24070 
    return
24071 
 
24072 
 
24073 
  def __repr__(self):
24074 
    L = ['%s=%r' % (key, value)
24075 
      for key, value in self.__dict__.iteritems()]
24076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24077 
 
24078 
  def __eq__(self, other):
24079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24080 
 
24081 
  def __ne__(self, other):
24082 
    return not (self == other)
9456 vikram.rag 24083 
 
24084 
class getSnapdealItembySkuAtSnapdeal_args:
24085 
  """
24086 
  Attributes:
24087 
   - skuAtSnapdeal
24088 
  """
24089 
 
24090 
  thrift_spec = None
24091 
  def __init__(self, skuAtSnapdeal=None,):
24092 
    self.skuAtSnapdeal = skuAtSnapdeal
24093 
 
24094 
  def read(self, iprot):
24095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24097 
      return
24098 
    iprot.readStructBegin()
24099 
    while True:
24100 
      (fname, ftype, fid) = iprot.readFieldBegin()
24101 
      if ftype == TType.STOP:
24102 
        break
24103 
      if fid == -1:
24104 
        if ftype == TType.STRING:
24105 
          self.skuAtSnapdeal = iprot.readString();
24106 
        else:
24107 
          iprot.skip(ftype)
24108 
      else:
24109 
        iprot.skip(ftype)
24110 
      iprot.readFieldEnd()
24111 
    iprot.readStructEnd()
24112 
 
24113 
  def write(self, oprot):
24114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24116 
      return
24117 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
24118 
    if self.skuAtSnapdeal is not None:
24119 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
24120 
      oprot.writeString(self.skuAtSnapdeal)
24121 
      oprot.writeFieldEnd()
24122 
    oprot.writeFieldStop()
24123 
    oprot.writeStructEnd()
24124 
 
24125 
  def validate(self):
24126 
    return
24127 
 
24128 
 
24129 
  def __repr__(self):
24130 
    L = ['%s=%r' % (key, value)
24131 
      for key, value in self.__dict__.iteritems()]
24132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24133 
 
24134 
  def __eq__(self, other):
24135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24136 
 
24137 
  def __ne__(self, other):
24138 
    return not (self == other)
24139 
 
24140 
class getSnapdealItembySkuAtSnapdeal_result:
24141 
  """
24142 
  Attributes:
24143 
   - success
24144 
  """
24145 
 
24146 
  thrift_spec = (
24147 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
24148 
  )
24149 
 
24150 
  def __init__(self, success=None,):
24151 
    self.success = success
24152 
 
24153 
  def read(self, iprot):
24154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24156 
      return
24157 
    iprot.readStructBegin()
24158 
    while True:
24159 
      (fname, ftype, fid) = iprot.readFieldBegin()
24160 
      if ftype == TType.STOP:
24161 
        break
24162 
      if fid == 0:
24163 
        if ftype == TType.STRUCT:
24164 
          self.success = SnapdealItem()
24165 
          self.success.read(iprot)
24166 
        else:
24167 
          iprot.skip(ftype)
24168 
      else:
24169 
        iprot.skip(ftype)
24170 
      iprot.readFieldEnd()
24171 
    iprot.readStructEnd()
24172 
 
24173 
  def write(self, oprot):
24174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24176 
      return
24177 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
24178 
    if self.success is not None:
24179 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24180 
      self.success.write(oprot)
24181 
      oprot.writeFieldEnd()
24182 
    oprot.writeFieldStop()
24183 
    oprot.writeStructEnd()
24184 
 
24185 
  def validate(self):
24186 
    return
24187 
 
24188 
 
24189 
  def __repr__(self):
24190 
    L = ['%s=%r' % (key, value)
24191 
      for key, value in self.__dict__.iteritems()]
24192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24193 
 
24194 
  def __eq__(self, other):
24195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24196 
 
24197 
  def __ne__(self, other):
24198 
    return not (self == other)
9621 manish.sha 24199 
 
24200 
class getProductFeedSubmit_args:
24201 
  """
24202 
  Attributes:
24203 
   - catalogItemId
24204 
  """
24205 
 
24206 
  thrift_spec = (
24207 
    None, # 0
24208 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24209 
  )
24210 
 
24211 
  def __init__(self, catalogItemId=None,):
24212 
    self.catalogItemId = catalogItemId
24213 
 
24214 
  def read(self, iprot):
24215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24217 
      return
24218 
    iprot.readStructBegin()
24219 
    while True:
24220 
      (fname, ftype, fid) = iprot.readFieldBegin()
24221 
      if ftype == TType.STOP:
24222 
        break
24223 
      if fid == 1:
24224 
        if ftype == TType.I64:
24225 
          self.catalogItemId = iprot.readI64();
24226 
        else:
24227 
          iprot.skip(ftype)
24228 
      else:
24229 
        iprot.skip(ftype)
24230 
      iprot.readFieldEnd()
24231 
    iprot.readStructEnd()
24232 
 
24233 
  def write(self, oprot):
24234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24236 
      return
24237 
    oprot.writeStructBegin('getProductFeedSubmit_args')
24238 
    if self.catalogItemId is not None:
24239 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24240 
      oprot.writeI64(self.catalogItemId)
24241 
      oprot.writeFieldEnd()
24242 
    oprot.writeFieldStop()
24243 
    oprot.writeStructEnd()
24244 
 
24245 
  def validate(self):
24246 
    return
24247 
 
24248 
 
24249 
  def __repr__(self):
24250 
    L = ['%s=%r' % (key, value)
24251 
      for key, value in self.__dict__.iteritems()]
24252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24253 
 
24254 
  def __eq__(self, other):
24255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24256 
 
24257 
  def __ne__(self, other):
24258 
    return not (self == other)
24259 
 
24260 
class getProductFeedSubmit_result:
24261 
  """
24262 
  Attributes:
24263 
   - success
24264 
   - cex
24265 
  """
24266 
 
24267 
  thrift_spec = (
24268 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
24269 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24270 
  )
24271 
 
24272 
  def __init__(self, success=None, cex=None,):
24273 
    self.success = success
24274 
    self.cex = cex
24275 
 
24276 
  def read(self, iprot):
24277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24279 
      return
24280 
    iprot.readStructBegin()
24281 
    while True:
24282 
      (fname, ftype, fid) = iprot.readFieldBegin()
24283 
      if ftype == TType.STOP:
24284 
        break
24285 
      if fid == 0:
24286 
        if ftype == TType.STRUCT:
24287 
          self.success = ProductFeedSubmit()
24288 
          self.success.read(iprot)
24289 
        else:
24290 
          iprot.skip(ftype)
24291 
      elif fid == 1:
24292 
        if ftype == TType.STRUCT:
24293 
          self.cex = CatalogServiceException()
24294 
          self.cex.read(iprot)
24295 
        else:
24296 
          iprot.skip(ftype)
24297 
      else:
24298 
        iprot.skip(ftype)
24299 
      iprot.readFieldEnd()
24300 
    iprot.readStructEnd()
24301 
 
24302 
  def write(self, oprot):
24303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24305 
      return
24306 
    oprot.writeStructBegin('getProductFeedSubmit_result')
24307 
    if self.success is not None:
24308 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24309 
      self.success.write(oprot)
24310 
      oprot.writeFieldEnd()
24311 
    if self.cex is not None:
24312 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24313 
      self.cex.write(oprot)
24314 
      oprot.writeFieldEnd()
24315 
    oprot.writeFieldStop()
24316 
    oprot.writeStructEnd()
24317 
 
24318 
  def validate(self):
24319 
    return
24320 
 
24321 
 
24322 
  def __repr__(self):
24323 
    L = ['%s=%r' % (key, value)
24324 
      for key, value in self.__dict__.iteritems()]
24325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24326 
 
24327 
  def __eq__(self, other):
24328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24329 
 
24330 
  def __ne__(self, other):
24331 
    return not (self == other)
24332 
 
24333 
class addProductFeedSubmit_args:
24334 
  """
24335 
  Attributes:
24336 
   - productFeedSubmit
24337 
  """
24338 
 
24339 
  thrift_spec = (
24340 
    None, # 0
24341 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24342 
  )
24343 
 
24344 
  def __init__(self, productFeedSubmit=None,):
24345 
    self.productFeedSubmit = productFeedSubmit
24346 
 
24347 
  def read(self, iprot):
24348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24350 
      return
24351 
    iprot.readStructBegin()
24352 
    while True:
24353 
      (fname, ftype, fid) = iprot.readFieldBegin()
24354 
      if ftype == TType.STOP:
24355 
        break
24356 
      if fid == 1:
24357 
        if ftype == TType.STRUCT:
24358 
          self.productFeedSubmit = ProductFeedSubmit()
24359 
          self.productFeedSubmit.read(iprot)
24360 
        else:
24361 
          iprot.skip(ftype)
24362 
      else:
24363 
        iprot.skip(ftype)
24364 
      iprot.readFieldEnd()
24365 
    iprot.readStructEnd()
24366 
 
24367 
  def write(self, oprot):
24368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24370 
      return
24371 
    oprot.writeStructBegin('addProductFeedSubmit_args')
24372 
    if self.productFeedSubmit is not None:
24373 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24374 
      self.productFeedSubmit.write(oprot)
24375 
      oprot.writeFieldEnd()
24376 
    oprot.writeFieldStop()
24377 
    oprot.writeStructEnd()
24378 
 
24379 
  def validate(self):
24380 
    return
24381 
 
24382 
 
24383 
  def __repr__(self):
24384 
    L = ['%s=%r' % (key, value)
24385 
      for key, value in self.__dict__.iteritems()]
24386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24387 
 
24388 
  def __eq__(self, other):
24389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24390 
 
24391 
  def __ne__(self, other):
24392 
    return not (self == other)
24393 
 
24394 
class addProductFeedSubmit_result:
24395 
  """
24396 
  Attributes:
24397 
   - success
24398 
   - cex
24399 
  """
24400 
 
24401 
  thrift_spec = (
24402 
    (0, TType.BOOL, 'success', None, None, ), # 0
24403 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24404 
  )
24405 
 
24406 
  def __init__(self, success=None, cex=None,):
24407 
    self.success = success
24408 
    self.cex = cex
24409 
 
24410 
  def read(self, iprot):
24411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24413 
      return
24414 
    iprot.readStructBegin()
24415 
    while True:
24416 
      (fname, ftype, fid) = iprot.readFieldBegin()
24417 
      if ftype == TType.STOP:
24418 
        break
24419 
      if fid == 0:
24420 
        if ftype == TType.BOOL:
24421 
          self.success = iprot.readBool();
24422 
        else:
24423 
          iprot.skip(ftype)
24424 
      elif fid == 1:
24425 
        if ftype == TType.STRUCT:
24426 
          self.cex = CatalogServiceException()
24427 
          self.cex.read(iprot)
24428 
        else:
24429 
          iprot.skip(ftype)
24430 
      else:
24431 
        iprot.skip(ftype)
24432 
      iprot.readFieldEnd()
24433 
    iprot.readStructEnd()
24434 
 
24435 
  def write(self, oprot):
24436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24438 
      return
24439 
    oprot.writeStructBegin('addProductFeedSubmit_result')
24440 
    if self.success is not None:
24441 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24442 
      oprot.writeBool(self.success)
24443 
      oprot.writeFieldEnd()
24444 
    if self.cex is not None:
24445 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24446 
      self.cex.write(oprot)
24447 
      oprot.writeFieldEnd()
24448 
    oprot.writeFieldStop()
24449 
    oprot.writeStructEnd()
24450 
 
24451 
  def validate(self):
24452 
    return
24453 
 
24454 
 
24455 
  def __repr__(self):
24456 
    L = ['%s=%r' % (key, value)
24457 
      for key, value in self.__dict__.iteritems()]
24458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24459 
 
24460 
  def __eq__(self, other):
24461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24462 
 
24463 
  def __ne__(self, other):
24464 
    return not (self == other)
24465 
 
24466 
class updateProductFeedSubmit_args:
24467 
  """
24468 
  Attributes:
24469 
   - productFeedSubmit
24470 
  """
24471 
 
24472 
  thrift_spec = (
24473 
    None, # 0
24474 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24475 
  )
24476 
 
24477 
  def __init__(self, productFeedSubmit=None,):
24478 
    self.productFeedSubmit = productFeedSubmit
24479 
 
24480 
  def read(self, iprot):
24481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24483 
      return
24484 
    iprot.readStructBegin()
24485 
    while True:
24486 
      (fname, ftype, fid) = iprot.readFieldBegin()
24487 
      if ftype == TType.STOP:
24488 
        break
24489 
      if fid == 1:
24490 
        if ftype == TType.STRUCT:
24491 
          self.productFeedSubmit = ProductFeedSubmit()
24492 
          self.productFeedSubmit.read(iprot)
24493 
        else:
24494 
          iprot.skip(ftype)
24495 
      else:
24496 
        iprot.skip(ftype)
24497 
      iprot.readFieldEnd()
24498 
    iprot.readStructEnd()
24499 
 
24500 
  def write(self, oprot):
24501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24503 
      return
24504 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
24505 
    if self.productFeedSubmit is not None:
24506 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24507 
      self.productFeedSubmit.write(oprot)
24508 
      oprot.writeFieldEnd()
24509 
    oprot.writeFieldStop()
24510 
    oprot.writeStructEnd()
24511 
 
24512 
  def validate(self):
24513 
    return
24514 
 
24515 
 
24516 
  def __repr__(self):
24517 
    L = ['%s=%r' % (key, value)
24518 
      for key, value in self.__dict__.iteritems()]
24519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24520 
 
24521 
  def __eq__(self, other):
24522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24523 
 
24524 
  def __ne__(self, other):
24525 
    return not (self == other)
24526 
 
24527 
class updateProductFeedSubmit_result:
24528 
  """
24529 
  Attributes:
24530 
   - success
24531 
   - cex
24532 
  """
24533 
 
24534 
  thrift_spec = (
24535 
    (0, TType.BOOL, 'success', None, None, ), # 0
24536 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24537 
  )
24538 
 
24539 
  def __init__(self, success=None, cex=None,):
24540 
    self.success = success
24541 
    self.cex = cex
24542 
 
24543 
  def read(self, iprot):
24544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24546 
      return
24547 
    iprot.readStructBegin()
24548 
    while True:
24549 
      (fname, ftype, fid) = iprot.readFieldBegin()
24550 
      if ftype == TType.STOP:
24551 
        break
24552 
      if fid == 0:
24553 
        if ftype == TType.BOOL:
24554 
          self.success = iprot.readBool();
24555 
        else:
24556 
          iprot.skip(ftype)
24557 
      elif fid == 1:
24558 
        if ftype == TType.STRUCT:
24559 
          self.cex = CatalogServiceException()
24560 
          self.cex.read(iprot)
24561 
        else:
24562 
          iprot.skip(ftype)
24563 
      else:
24564 
        iprot.skip(ftype)
24565 
      iprot.readFieldEnd()
24566 
    iprot.readStructEnd()
24567 
 
24568 
  def write(self, oprot):
24569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24571 
      return
24572 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
24573 
    if self.success is not None:
24574 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24575 
      oprot.writeBool(self.success)
24576 
      oprot.writeFieldEnd()
24577 
    if self.cex is not None:
24578 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24579 
      self.cex.write(oprot)
24580 
      oprot.writeFieldEnd()
24581 
    oprot.writeFieldStop()
24582 
    oprot.writeStructEnd()
24583 
 
24584 
  def validate(self):
24585 
    return
24586 
 
24587 
 
24588 
  def __repr__(self):
24589 
    L = ['%s=%r' % (key, value)
24590 
      for key, value in self.__dict__.iteritems()]
24591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24592 
 
24593 
  def __eq__(self, other):
24594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24595 
 
24596 
  def __ne__(self, other):
24597 
    return not (self == other)
24598 
 
24599 
class deleteProductFeedSubmit_args:
24600 
  """
24601 
  Attributes:
24602 
   - catalogItemId
24603 
  """
24604 
 
24605 
  thrift_spec = (
24606 
    None, # 0
24607 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24608 
  )
24609 
 
24610 
  def __init__(self, catalogItemId=None,):
24611 
    self.catalogItemId = catalogItemId
24612 
 
24613 
  def read(self, iprot):
24614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24616 
      return
24617 
    iprot.readStructBegin()
24618 
    while True:
24619 
      (fname, ftype, fid) = iprot.readFieldBegin()
24620 
      if ftype == TType.STOP:
24621 
        break
24622 
      if fid == 1:
24623 
        if ftype == TType.I64:
24624 
          self.catalogItemId = iprot.readI64();
24625 
        else:
24626 
          iprot.skip(ftype)
24627 
      else:
24628 
        iprot.skip(ftype)
24629 
      iprot.readFieldEnd()
24630 
    iprot.readStructEnd()
24631 
 
24632 
  def write(self, oprot):
24633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24635 
      return
24636 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
24637 
    if self.catalogItemId is not None:
24638 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24639 
      oprot.writeI64(self.catalogItemId)
24640 
      oprot.writeFieldEnd()
24641 
    oprot.writeFieldStop()
24642 
    oprot.writeStructEnd()
24643 
 
24644 
  def validate(self):
24645 
    return
24646 
 
24647 
 
24648 
  def __repr__(self):
24649 
    L = ['%s=%r' % (key, value)
24650 
      for key, value in self.__dict__.iteritems()]
24651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24652 
 
24653 
  def __eq__(self, other):
24654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24655 
 
24656 
  def __ne__(self, other):
24657 
    return not (self == other)
24658 
 
24659 
class deleteProductFeedSubmit_result:
24660 
  """
24661 
  Attributes:
24662 
   - success
24663 
   - cex
24664 
  """
24665 
 
24666 
  thrift_spec = (
24667 
    (0, TType.BOOL, 'success', None, None, ), # 0
24668 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24669 
  )
24670 
 
24671 
  def __init__(self, success=None, cex=None,):
24672 
    self.success = success
24673 
    self.cex = cex
24674 
 
24675 
  def read(self, iprot):
24676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24678 
      return
24679 
    iprot.readStructBegin()
24680 
    while True:
24681 
      (fname, ftype, fid) = iprot.readFieldBegin()
24682 
      if ftype == TType.STOP:
24683 
        break
24684 
      if fid == 0:
24685 
        if ftype == TType.BOOL:
24686 
          self.success = iprot.readBool();
24687 
        else:
24688 
          iprot.skip(ftype)
24689 
      elif fid == 1:
24690 
        if ftype == TType.STRUCT:
24691 
          self.cex = CatalogServiceException()
24692 
          self.cex.read(iprot)
24693 
        else:
24694 
          iprot.skip(ftype)
24695 
      else:
24696 
        iprot.skip(ftype)
24697 
      iprot.readFieldEnd()
24698 
    iprot.readStructEnd()
24699 
 
24700 
  def write(self, oprot):
24701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24703 
      return
24704 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
24705 
    if self.success is not None:
24706 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24707 
      oprot.writeBool(self.success)
24708 
      oprot.writeFieldEnd()
24709 
    if self.cex is not None:
24710 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24711 
      self.cex.write(oprot)
24712 
      oprot.writeFieldEnd()
24713 
    oprot.writeFieldStop()
24714 
    oprot.writeStructEnd()
24715 
 
24716 
  def validate(self):
24717 
    return
24718 
 
24719 
 
24720 
  def __repr__(self):
24721 
    L = ['%s=%r' % (key, value)
24722 
      for key, value in self.__dict__.iteritems()]
24723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24724 
 
24725 
  def __eq__(self, other):
24726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24727 
 
24728 
  def __ne__(self, other):
24729 
    return not (self == other)
24730 
 
24731 
class getAllProductFeedSubmit_args:
24732 
 
24733 
  thrift_spec = (
24734 
  )
24735 
 
24736 
  def read(self, iprot):
24737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24739 
      return
24740 
    iprot.readStructBegin()
24741 
    while True:
24742 
      (fname, ftype, fid) = iprot.readFieldBegin()
24743 
      if ftype == TType.STOP:
24744 
        break
24745 
      else:
24746 
        iprot.skip(ftype)
24747 
      iprot.readFieldEnd()
24748 
    iprot.readStructEnd()
24749 
 
24750 
  def write(self, oprot):
24751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24753 
      return
24754 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
24755 
    oprot.writeFieldStop()
24756 
    oprot.writeStructEnd()
24757 
 
24758 
  def validate(self):
24759 
    return
24760 
 
24761 
 
24762 
  def __repr__(self):
24763 
    L = ['%s=%r' % (key, value)
24764 
      for key, value in self.__dict__.iteritems()]
24765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24766 
 
24767 
  def __eq__(self, other):
24768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24769 
 
24770 
  def __ne__(self, other):
24771 
    return not (self == other)
24772 
 
24773 
class getAllProductFeedSubmit_result:
24774 
  """
24775 
  Attributes:
24776 
   - success
24777 
   - cex
24778 
  """
24779 
 
24780 
  thrift_spec = (
24781 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
24782 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24783 
  )
24784 
 
24785 
  def __init__(self, success=None, cex=None,):
24786 
    self.success = success
24787 
    self.cex = cex
24788 
 
24789 
  def read(self, iprot):
24790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24792 
      return
24793 
    iprot.readStructBegin()
24794 
    while True:
24795 
      (fname, ftype, fid) = iprot.readFieldBegin()
24796 
      if ftype == TType.STOP:
24797 
        break
24798 
      if fid == 0:
24799 
        if ftype == TType.LIST:
24800 
          self.success = []
24801 
          (_etype551, _size548) = iprot.readListBegin()
24802 
          for _i552 in xrange(_size548):
24803 
            _elem553 = ProductFeedSubmit()
24804 
            _elem553.read(iprot)
24805 
            self.success.append(_elem553)
24806 
          iprot.readListEnd()
24807 
        else:
24808 
          iprot.skip(ftype)
24809 
      elif fid == 1:
24810 
        if ftype == TType.STRUCT:
24811 
          self.cex = CatalogServiceException()
24812 
          self.cex.read(iprot)
24813 
        else:
24814 
          iprot.skip(ftype)
24815 
      else:
24816 
        iprot.skip(ftype)
24817 
      iprot.readFieldEnd()
24818 
    iprot.readStructEnd()
24819 
 
24820 
  def write(self, oprot):
24821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24823 
      return
24824 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
24825 
    if self.success is not None:
24826 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24827 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24828 
      for iter554 in self.success:
24829 
        iter554.write(oprot)
24830 
      oprot.writeListEnd()
24831 
      oprot.writeFieldEnd()
24832 
    if self.cex is not None:
24833 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24834 
      self.cex.write(oprot)
24835 
      oprot.writeFieldEnd()
24836 
    oprot.writeFieldStop()
24837 
    oprot.writeStructEnd()
24838 
 
24839 
  def validate(self):
24840 
    return
24841 
 
24842 
 
24843 
  def __repr__(self):
24844 
    L = ['%s=%r' % (key, value)
24845 
      for key, value in self.__dict__.iteritems()]
24846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24847 
 
24848 
  def __eq__(self, other):
24849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24850 
 
24851 
  def __ne__(self, other):
24852 
    return not (self == other)
9724 kshitij.so 24853 
 
24854 
class getMarketplacedetailsForItem_args:
24855 
  """
24856 
  Attributes:
24857 
   - itemId
24858 
   - sourceId
24859 
  """
24860 
 
24861 
  thrift_spec = (
24862 
    None, # 0
24863 
    (1, TType.I64, 'itemId', None, None, ), # 1
24864 
    (2, TType.I64, 'sourceId', None, None, ), # 2
24865 
  )
24866 
 
24867 
  def __init__(self, itemId=None, sourceId=None,):
24868 
    self.itemId = itemId
24869 
    self.sourceId = sourceId
24870 
 
24871 
  def read(self, iprot):
24872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24874 
      return
24875 
    iprot.readStructBegin()
24876 
    while True:
24877 
      (fname, ftype, fid) = iprot.readFieldBegin()
24878 
      if ftype == TType.STOP:
24879 
        break
24880 
      if fid == 1:
24881 
        if ftype == TType.I64:
24882 
          self.itemId = iprot.readI64();
24883 
        else:
24884 
          iprot.skip(ftype)
24885 
      elif fid == 2:
24886 
        if ftype == TType.I64:
24887 
          self.sourceId = iprot.readI64();
24888 
        else:
24889 
          iprot.skip(ftype)
24890 
      else:
24891 
        iprot.skip(ftype)
24892 
      iprot.readFieldEnd()
24893 
    iprot.readStructEnd()
24894 
 
24895 
  def write(self, oprot):
24896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24898 
      return
24899 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
24900 
    if self.itemId is not None:
24901 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24902 
      oprot.writeI64(self.itemId)
24903 
      oprot.writeFieldEnd()
24904 
    if self.sourceId is not None:
24905 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
24906 
      oprot.writeI64(self.sourceId)
24907 
      oprot.writeFieldEnd()
24908 
    oprot.writeFieldStop()
24909 
    oprot.writeStructEnd()
24910 
 
24911 
  def validate(self):
24912 
    return
24913 
 
24914 
 
24915 
  def __repr__(self):
24916 
    L = ['%s=%r' % (key, value)
24917 
      for key, value in self.__dict__.iteritems()]
24918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24919 
 
24920 
  def __eq__(self, other):
24921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24922 
 
24923 
  def __ne__(self, other):
24924 
    return not (self == other)
24925 
 
24926 
class getMarketplacedetailsForItem_result:
24927 
  """
24928 
  Attributes:
24929 
   - success
24930 
  """
24931 
 
24932 
  thrift_spec = (
24933 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
24934 
  )
24935 
 
24936 
  def __init__(self, success=None,):
24937 
    self.success = success
24938 
 
24939 
  def read(self, iprot):
24940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24942 
      return
24943 
    iprot.readStructBegin()
24944 
    while True:
24945 
      (fname, ftype, fid) = iprot.readFieldBegin()
24946 
      if ftype == TType.STOP:
24947 
        break
24948 
      if fid == 0:
24949 
        if ftype == TType.STRUCT:
24950 
          self.success = MarketplaceItems()
24951 
          self.success.read(iprot)
24952 
        else:
24953 
          iprot.skip(ftype)
24954 
      else:
24955 
        iprot.skip(ftype)
24956 
      iprot.readFieldEnd()
24957 
    iprot.readStructEnd()
24958 
 
24959 
  def write(self, oprot):
24960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24962 
      return
24963 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
24964 
    if self.success is not None:
24965 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24966 
      self.success.write(oprot)
24967 
      oprot.writeFieldEnd()
24968 
    oprot.writeFieldStop()
24969 
    oprot.writeStructEnd()
24970 
 
24971 
  def validate(self):
24972 
    return
24973 
 
24974 
 
24975 
  def __repr__(self):
24976 
    L = ['%s=%r' % (key, value)
24977 
      for key, value in self.__dict__.iteritems()]
24978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24979 
 
24980 
  def __eq__(self, other):
24981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24982 
 
24983 
  def __ne__(self, other):
24984 
    return not (self == other)
24985 
 
24986 
class updateMarketplaceAttributesForItem_args:
24987 
  """
24988 
  Attributes:
24989 
   - marketPlaceItem
24990 
  """
24991 
 
24992 
  thrift_spec = (
24993 
    None, # 0
24994 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
24995 
  )
24996 
 
24997 
  def __init__(self, marketPlaceItem=None,):
24998 
    self.marketPlaceItem = marketPlaceItem
24999 
 
25000 
  def read(self, iprot):
25001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25003 
      return
25004 
    iprot.readStructBegin()
25005 
    while True:
25006 
      (fname, ftype, fid) = iprot.readFieldBegin()
25007 
      if ftype == TType.STOP:
25008 
        break
25009 
      if fid == 1:
25010 
        if ftype == TType.STRUCT:
25011 
          self.marketPlaceItem = MarketplaceItems()
25012 
          self.marketPlaceItem.read(iprot)
25013 
        else:
25014 
          iprot.skip(ftype)
25015 
      else:
25016 
        iprot.skip(ftype)
25017 
      iprot.readFieldEnd()
25018 
    iprot.readStructEnd()
25019 
 
25020 
  def write(self, oprot):
25021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25023 
      return
25024 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
25025 
    if self.marketPlaceItem is not None:
25026 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
25027 
      self.marketPlaceItem.write(oprot)
25028 
      oprot.writeFieldEnd()
25029 
    oprot.writeFieldStop()
25030 
    oprot.writeStructEnd()
25031 
 
25032 
  def validate(self):
25033 
    return
25034 
 
25035 
 
25036 
  def __repr__(self):
25037 
    L = ['%s=%r' % (key, value)
25038 
      for key, value in self.__dict__.iteritems()]
25039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25040 
 
25041 
  def __eq__(self, other):
25042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25043 
 
25044 
  def __ne__(self, other):
25045 
    return not (self == other)
25046 
 
25047 
class updateMarketplaceAttributesForItem_result:
25048 
  """
25049 
  Attributes:
25050 
   - success
25051 
  """
25052 
 
25053 
  thrift_spec = (
25054 
    (0, TType.BOOL, 'success', None, None, ), # 0
25055 
  )
25056 
 
25057 
  def __init__(self, success=None,):
25058 
    self.success = success
25059 
 
25060 
  def read(self, iprot):
25061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25063 
      return
25064 
    iprot.readStructBegin()
25065 
    while True:
25066 
      (fname, ftype, fid) = iprot.readFieldBegin()
25067 
      if ftype == TType.STOP:
25068 
        break
25069 
      if fid == 0:
25070 
        if ftype == TType.BOOL:
25071 
          self.success = iprot.readBool();
25072 
        else:
25073 
          iprot.skip(ftype)
25074 
      else:
25075 
        iprot.skip(ftype)
25076 
      iprot.readFieldEnd()
25077 
    iprot.readStructEnd()
25078 
 
25079 
  def write(self, oprot):
25080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25082 
      return
25083 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
25084 
    if self.success is not None:
25085 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25086 
      oprot.writeBool(self.success)
25087 
      oprot.writeFieldEnd()
25088 
    oprot.writeFieldStop()
25089 
    oprot.writeStructEnd()
25090 
 
25091 
  def validate(self):
25092 
    return
25093 
 
25094 
 
25095 
  def __repr__(self):
25096 
    L = ['%s=%r' % (key, value)
25097 
      for key, value in self.__dict__.iteritems()]
25098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25099 
 
25100 
  def __eq__(self, other):
25101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25102 
 
25103 
  def __ne__(self, other):
25104 
    return not (self == other)
9776 vikram.rag 25105 
 
9779 kshitij.so 25106 
class getCostingForMarketplace_args:
25107 
  """
25108 
  Attributes:
25109 
   - source
25110 
   - item_id
25111 
  """
25112 
 
25113 
  thrift_spec = (
25114 
    None, # 0
25115 
    (1, TType.I64, 'source', None, None, ), # 1
25116 
    (2, TType.I64, 'item_id', None, None, ), # 2
25117 
  )
25118 
 
25119 
  def __init__(self, source=None, item_id=None,):
25120 
    self.source = source
25121 
    self.item_id = item_id
25122 
 
25123 
  def read(self, iprot):
25124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25126 
      return
25127 
    iprot.readStructBegin()
25128 
    while True:
25129 
      (fname, ftype, fid) = iprot.readFieldBegin()
25130 
      if ftype == TType.STOP:
25131 
        break
25132 
      if fid == 1:
25133 
        if ftype == TType.I64:
25134 
          self.source = iprot.readI64();
25135 
        else:
25136 
          iprot.skip(ftype)
25137 
      elif fid == 2:
25138 
        if ftype == TType.I64:
25139 
          self.item_id = iprot.readI64();
25140 
        else:
25141 
          iprot.skip(ftype)
25142 
      else:
25143 
        iprot.skip(ftype)
25144 
      iprot.readFieldEnd()
25145 
    iprot.readStructEnd()
25146 
 
25147 
  def write(self, oprot):
25148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25150 
      return
25151 
    oprot.writeStructBegin('getCostingForMarketplace_args')
25152 
    if self.source is not None:
25153 
      oprot.writeFieldBegin('source', TType.I64, 1)
25154 
      oprot.writeI64(self.source)
25155 
      oprot.writeFieldEnd()
25156 
    if self.item_id is not None:
25157 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
25158 
      oprot.writeI64(self.item_id)
25159 
      oprot.writeFieldEnd()
25160 
    oprot.writeFieldStop()
25161 
    oprot.writeStructEnd()
25162 
 
25163 
  def validate(self):
25164 
    return
25165 
 
25166 
 
25167 
  def __repr__(self):
25168 
    L = ['%s=%r' % (key, value)
25169 
      for key, value in self.__dict__.iteritems()]
25170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25171 
 
25172 
  def __eq__(self, other):
25173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25174 
 
25175 
  def __ne__(self, other):
25176 
    return not (self == other)
25177 
 
25178 
class getCostingForMarketplace_result:
25179 
  """
25180 
  Attributes:
25181 
   - success
25182 
  """
25183 
 
25184 
  thrift_spec = (
25185 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
25186 
  )
25187 
 
25188 
  def __init__(self, success=None,):
25189 
    self.success = success
25190 
 
25191 
  def read(self, iprot):
25192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25194 
      return
25195 
    iprot.readStructBegin()
25196 
    while True:
25197 
      (fname, ftype, fid) = iprot.readFieldBegin()
25198 
      if ftype == TType.STOP:
25199 
        break
25200 
      if fid == 0:
25201 
        if ftype == TType.STRUCT:
25202 
          self.success = MarketplacePercentage()
25203 
          self.success.read(iprot)
25204 
        else:
25205 
          iprot.skip(ftype)
25206 
      else:
25207 
        iprot.skip(ftype)
25208 
      iprot.readFieldEnd()
25209 
    iprot.readStructEnd()
25210 
 
25211 
  def write(self, oprot):
25212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25214 
      return
25215 
    oprot.writeStructBegin('getCostingForMarketplace_result')
25216 
    if self.success is not None:
25217 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25218 
      self.success.write(oprot)
25219 
      oprot.writeFieldEnd()
25220 
    oprot.writeFieldStop()
25221 
    oprot.writeStructEnd()
25222 
 
25223 
  def validate(self):
25224 
    return
25225 
 
25226 
 
25227 
  def __repr__(self):
25228 
    L = ['%s=%r' % (key, value)
25229 
      for key, value in self.__dict__.iteritems()]
25230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25231 
 
25232 
  def __eq__(self, other):
25233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25234 
 
25235 
  def __ne__(self, other):
25236 
    return not (self == other)
25237 
 
9776 vikram.rag 25238 
class getMarketPlaceItemsForPriceUpdate_args:
25239 
  """
25240 
  Attributes:
25241 
   - source
25242 
  """
25243 
 
25244 
  thrift_spec = (
25245 
    None, # 0
25246 
    (1, TType.I64, 'source', None, None, ), # 1
25247 
  )
25248 
 
25249 
  def __init__(self, source=None,):
25250 
    self.source = source
25251 
 
25252 
  def read(self, iprot):
25253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25255 
      return
25256 
    iprot.readStructBegin()
25257 
    while True:
25258 
      (fname, ftype, fid) = iprot.readFieldBegin()
25259 
      if ftype == TType.STOP:
25260 
        break
25261 
      if fid == 1:
25262 
        if ftype == TType.I64:
25263 
          self.source = iprot.readI64();
25264 
        else:
25265 
          iprot.skip(ftype)
25266 
      else:
25267 
        iprot.skip(ftype)
25268 
      iprot.readFieldEnd()
25269 
    iprot.readStructEnd()
25270 
 
25271 
  def write(self, oprot):
25272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25274 
      return
25275 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
25276 
    if self.source is not None:
25277 
      oprot.writeFieldBegin('source', TType.I64, 1)
25278 
      oprot.writeI64(self.source)
25279 
      oprot.writeFieldEnd()
25280 
    oprot.writeFieldStop()
25281 
    oprot.writeStructEnd()
25282 
 
25283 
  def validate(self):
25284 
    return
25285 
 
25286 
 
25287 
  def __repr__(self):
25288 
    L = ['%s=%r' % (key, value)
25289 
      for key, value in self.__dict__.iteritems()]
25290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25291 
 
25292 
  def __eq__(self, other):
25293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25294 
 
25295 
  def __ne__(self, other):
25296 
    return not (self == other)
25297 
 
25298 
class getMarketPlaceItemsForPriceUpdate_result:
25299 
  """
25300 
  Attributes:
25301 
   - success
25302 
  """
25303 
 
25304 
  thrift_spec = (
25305 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
25306 
  )
25307 
 
25308 
  def __init__(self, success=None,):
25309 
    self.success = success
25310 
 
25311 
  def read(self, iprot):
25312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25314 
      return
25315 
    iprot.readStructBegin()
25316 
    while True:
25317 
      (fname, ftype, fid) = iprot.readFieldBegin()
25318 
      if ftype == TType.STOP:
25319 
        break
25320 
      if fid == 0:
25321 
        if ftype == TType.LIST:
25322 
          self.success = []
25323 
          (_etype558, _size555) = iprot.readListBegin()
25324 
          for _i559 in xrange(_size555):
25325 
            _elem560 = MarketPlaceItemPrice()
25326 
            _elem560.read(iprot)
25327 
            self.success.append(_elem560)
25328 
          iprot.readListEnd()
25329 
        else:
25330 
          iprot.skip(ftype)
25331 
      else:
25332 
        iprot.skip(ftype)
25333 
      iprot.readFieldEnd()
25334 
    iprot.readStructEnd()
25335 
 
25336 
  def write(self, oprot):
25337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25339 
      return
25340 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
25341 
    if self.success is not None:
25342 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25343 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25344 
      for iter561 in self.success:
25345 
        iter561.write(oprot)
25346 
      oprot.writeListEnd()
25347 
      oprot.writeFieldEnd()
25348 
    oprot.writeFieldStop()
25349 
    oprot.writeStructEnd()
25350 
 
25351 
  def validate(self):
25352 
    return
25353 
 
25354 
 
25355 
  def __repr__(self):
25356 
    L = ['%s=%r' % (key, value)
25357 
      for key, value in self.__dict__.iteritems()]
25358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25359 
 
25360 
  def __eq__(self, other):
25361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25362 
 
25363 
  def __ne__(self, other):
25364 
    return not (self == other)
25365 
 
25366 
class updateMarketPlacePriceUpdateStatus_args:
25367 
  """
25368 
  Attributes:
25369 
   - skulist
25370 
   - timestamp
9816 kshitij.so 25371 
   - source
9776 vikram.rag 25372 
  """
25373 
 
25374 
  thrift_spec = (
25375 
    None, # 0
25376 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
25377 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 25378 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 25379 
  )
25380 
 
9816 kshitij.so 25381 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 25382 
    self.skulist = skulist
25383 
    self.timestamp = timestamp
9816 kshitij.so 25384 
    self.source = source
9776 vikram.rag 25385 
 
25386 
  def read(self, iprot):
25387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25389 
      return
25390 
    iprot.readStructBegin()
25391 
    while True:
25392 
      (fname, ftype, fid) = iprot.readFieldBegin()
25393 
      if ftype == TType.STOP:
25394 
        break
25395 
      if fid == 1:
25396 
        if ftype == TType.LIST:
25397 
          self.skulist = []
25398 
          (_etype565, _size562) = iprot.readListBegin()
25399 
          for _i566 in xrange(_size562):
25400 
            _elem567 = iprot.readI64();
25401 
            self.skulist.append(_elem567)
25402 
          iprot.readListEnd()
25403 
        else:
25404 
          iprot.skip(ftype)
25405 
      elif fid == 2:
25406 
        if ftype == TType.I64:
25407 
          self.timestamp = iprot.readI64();
25408 
        else:
25409 
          iprot.skip(ftype)
9816 kshitij.so 25410 
      elif fid == 3:
25411 
        if ftype == TType.I64:
25412 
          self.source = iprot.readI64();
25413 
        else:
25414 
          iprot.skip(ftype)
9776 vikram.rag 25415 
      else:
25416 
        iprot.skip(ftype)
25417 
      iprot.readFieldEnd()
25418 
    iprot.readStructEnd()
25419 
 
25420 
  def write(self, oprot):
25421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25423 
      return
25424 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
25425 
    if self.skulist is not None:
25426 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
25427 
      oprot.writeListBegin(TType.I64, len(self.skulist))
25428 
      for iter568 in self.skulist:
25429 
        oprot.writeI64(iter568)
25430 
      oprot.writeListEnd()
25431 
      oprot.writeFieldEnd()
25432 
    if self.timestamp is not None:
25433 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
25434 
      oprot.writeI64(self.timestamp)
25435 
      oprot.writeFieldEnd()
9816 kshitij.so 25436 
    if self.source is not None:
25437 
      oprot.writeFieldBegin('source', TType.I64, 3)
25438 
      oprot.writeI64(self.source)
25439 
      oprot.writeFieldEnd()
9776 vikram.rag 25440 
    oprot.writeFieldStop()
25441 
    oprot.writeStructEnd()
25442 
 
25443 
  def validate(self):
25444 
    return
25445 
 
25446 
 
25447 
  def __repr__(self):
25448 
    L = ['%s=%r' % (key, value)
25449 
      for key, value in self.__dict__.iteritems()]
25450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25451 
 
25452 
  def __eq__(self, other):
25453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25454 
 
25455 
  def __ne__(self, other):
25456 
    return not (self == other)
25457 
 
25458 
class updateMarketPlacePriceUpdateStatus_result:
25459 
 
25460 
  thrift_spec = (
25461 
  )
25462 
 
25463 
  def read(self, iprot):
25464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25466 
      return
25467 
    iprot.readStructBegin()
25468 
    while True:
25469 
      (fname, ftype, fid) = iprot.readFieldBegin()
25470 
      if ftype == TType.STOP:
25471 
        break
25472 
      else:
25473 
        iprot.skip(ftype)
25474 
      iprot.readFieldEnd()
25475 
    iprot.readStructEnd()
25476 
 
25477 
  def write(self, oprot):
25478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25480 
      return
25481 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
25482 
    oprot.writeFieldStop()
25483 
    oprot.writeStructEnd()
25484 
 
25485 
  def validate(self):
25486 
    return
25487 
 
25488 
 
25489 
  def __repr__(self):
25490 
    L = ['%s=%r' % (key, value)
25491 
      for key, value in self.__dict__.iteritems()]
25492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25493 
 
25494 
  def __eq__(self, other):
25495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25496 
 
25497 
  def __ne__(self, other):
25498 
    return not (self == other)
9861 rajveer 25499 
 
25500 
class updateItemHoldInventory_args:
25501 
  """
25502 
  Attributes:
25503 
   - itemHoldMap
25504 
  """
25505 
 
25506 
  thrift_spec = (
25507 
    None, # 0
25508 
    (1, TType.MAP, 'itemHoldMap', (TType.I64,None,TType.I64,None), None, ), # 1
25509 
  )
25510 
 
25511 
  def __init__(self, itemHoldMap=None,):
25512 
    self.itemHoldMap = itemHoldMap
25513 
 
25514 
  def read(self, iprot):
25515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25517 
      return
25518 
    iprot.readStructBegin()
25519 
    while True:
25520 
      (fname, ftype, fid) = iprot.readFieldBegin()
25521 
      if ftype == TType.STOP:
25522 
        break
25523 
      if fid == 1:
25524 
        if ftype == TType.MAP:
25525 
          self.itemHoldMap = {}
25526 
          (_ktype570, _vtype571, _size569 ) = iprot.readMapBegin()
25527 
          for _i573 in xrange(_size569):
25528 
            _key574 = iprot.readI64();
25529 
            _val575 = iprot.readI64();
25530 
            self.itemHoldMap[_key574] = _val575
25531 
          iprot.readMapEnd()
25532 
        else:
25533 
          iprot.skip(ftype)
25534 
      else:
25535 
        iprot.skip(ftype)
25536 
      iprot.readFieldEnd()
25537 
    iprot.readStructEnd()
25538 
 
25539 
  def write(self, oprot):
25540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25542 
      return
25543 
    oprot.writeStructBegin('updateItemHoldInventory_args')
25544 
    if self.itemHoldMap is not None:
25545 
      oprot.writeFieldBegin('itemHoldMap', TType.MAP, 1)
25546 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemHoldMap))
25547 
      for kiter576,viter577 in self.itemHoldMap.items():
25548 
        oprot.writeI64(kiter576)
25549 
        oprot.writeI64(viter577)
25550 
      oprot.writeMapEnd()
25551 
      oprot.writeFieldEnd()
25552 
    oprot.writeFieldStop()
25553 
    oprot.writeStructEnd()
25554 
 
25555 
  def validate(self):
25556 
    return
25557 
 
25558 
 
25559 
  def __repr__(self):
25560 
    L = ['%s=%r' % (key, value)
25561 
      for key, value in self.__dict__.iteritems()]
25562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25563 
 
25564 
  def __eq__(self, other):
25565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25566 
 
25567 
  def __ne__(self, other):
25568 
    return not (self == other)
25569 
 
25570 
class updateItemHoldInventory_result:
25571 
 
25572 
  thrift_spec = (
25573 
  )
25574 
 
25575 
  def read(self, iprot):
25576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25578 
      return
25579 
    iprot.readStructBegin()
25580 
    while True:
25581 
      (fname, ftype, fid) = iprot.readFieldBegin()
25582 
      if ftype == TType.STOP:
25583 
        break
25584 
      else:
25585 
        iprot.skip(ftype)
25586 
      iprot.readFieldEnd()
25587 
    iprot.readStructEnd()
25588 
 
25589 
  def write(self, oprot):
25590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25592 
      return
25593 
    oprot.writeStructBegin('updateItemHoldInventory_result')
25594 
    oprot.writeFieldStop()
25595 
    oprot.writeStructEnd()
25596 
 
25597 
  def validate(self):
25598 
    return
25599 
 
25600 
 
25601 
  def __repr__(self):
25602 
    L = ['%s=%r' % (key, value)
25603 
      for key, value in self.__dict__.iteritems()]
25604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25605 
 
25606 
  def __eq__(self, other):
25607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25608 
 
25609 
  def __ne__(self, other):
25610 
    return not (self == other)
9895 vikram.rag 25611 
 
25612 
class updateNlcAtMarketplaces_args:
25613 
  """
25614 
  Attributes:
25615 
   - item_id
25616 
   - vendor_id
25617 
   - nlc
25618 
  """
25619 
 
25620 
  thrift_spec = None
25621 
  def __init__(self, item_id=None, vendor_id=None, nlc=None,):
25622 
    self.item_id = item_id
25623 
    self.vendor_id = vendor_id
25624 
    self.nlc = nlc
25625 
 
25626 
  def read(self, iprot):
25627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25629 
      return
25630 
    iprot.readStructBegin()
25631 
    while True:
25632 
      (fname, ftype, fid) = iprot.readFieldBegin()
25633 
      if ftype == TType.STOP:
25634 
        break
25635 
      if fid == 1:
25636 
        if ftype == TType.I64:
25637 
          self.item_id = iprot.readI64();
25638 
        else:
25639 
          iprot.skip(ftype)
25640 
      elif fid == 2:
25641 
        if ftype == TType.I64:
25642 
          self.vendor_id = iprot.readI64();
25643 
        else:
25644 
          iprot.skip(ftype)
25645 
      elif fid == -1:
25646 
        if ftype == TType.DOUBLE:
25647 
          self.nlc = iprot.readDouble();
25648 
        else:
25649 
          iprot.skip(ftype)
25650 
      else:
25651 
        iprot.skip(ftype)
25652 
      iprot.readFieldEnd()
25653 
    iprot.readStructEnd()
25654 
 
25655 
  def write(self, oprot):
25656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25658 
      return
25659 
    oprot.writeStructBegin('updateNlcAtMarketplaces_args')
25660 
    if self.nlc is not None:
25661 
      oprot.writeFieldBegin('nlc', TType.DOUBLE, -1)
25662 
      oprot.writeDouble(self.nlc)
25663 
      oprot.writeFieldEnd()
25664 
    if self.item_id is not None:
25665 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
25666 
      oprot.writeI64(self.item_id)
25667 
      oprot.writeFieldEnd()
25668 
    if self.vendor_id is not None:
25669 
      oprot.writeFieldBegin('vendor_id', TType.I64, 2)
25670 
      oprot.writeI64(self.vendor_id)
25671 
      oprot.writeFieldEnd()
25672 
    oprot.writeFieldStop()
25673 
    oprot.writeStructEnd()
25674 
 
25675 
  def validate(self):
25676 
    return
25677 
 
25678 
 
25679 
  def __repr__(self):
25680 
    L = ['%s=%r' % (key, value)
25681 
      for key, value in self.__dict__.iteritems()]
25682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25683 
 
25684 
  def __eq__(self, other):
25685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25686 
 
25687 
  def __ne__(self, other):
25688 
    return not (self == other)
25689 
 
25690 
class updateNlcAtMarketplaces_result:
25691 
 
25692 
  thrift_spec = (
25693 
  )
25694 
 
25695 
  def read(self, iprot):
25696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25698 
      return
25699 
    iprot.readStructBegin()
25700 
    while True:
25701 
      (fname, ftype, fid) = iprot.readFieldBegin()
25702 
      if ftype == TType.STOP:
25703 
        break
25704 
      else:
25705 
        iprot.skip(ftype)
25706 
      iprot.readFieldEnd()
25707 
    iprot.readStructEnd()
25708 
 
25709 
  def write(self, oprot):
25710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25712 
      return
25713 
    oprot.writeStructBegin('updateNlcAtMarketplaces_result')
25714 
    oprot.writeFieldStop()
25715 
    oprot.writeStructEnd()
25716 
 
25717 
  def validate(self):
25718 
    return
25719 
 
25720 
 
25721 
  def __repr__(self):
25722 
    L = ['%s=%r' % (key, value)
25723 
      for key, value in self.__dict__.iteritems()]
25724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25725 
 
25726 
  def __eq__(self, other):
25727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25728 
 
25729 
  def __ne__(self, other):
25730 
    return not (self == other)
9945 vikram.rag 25731 
 
25732 
class getAllFlipkartItems_args:
25733 
 
25734 
  thrift_spec = (
25735 
  )
25736 
 
25737 
  def read(self, iprot):
25738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25740 
      return
25741 
    iprot.readStructBegin()
25742 
    while True:
25743 
      (fname, ftype, fid) = iprot.readFieldBegin()
25744 
      if ftype == TType.STOP:
25745 
        break
25746 
      else:
25747 
        iprot.skip(ftype)
25748 
      iprot.readFieldEnd()
25749 
    iprot.readStructEnd()
25750 
 
25751 
  def write(self, oprot):
25752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25754 
      return
25755 
    oprot.writeStructBegin('getAllFlipkartItems_args')
25756 
    oprot.writeFieldStop()
25757 
    oprot.writeStructEnd()
25758 
 
25759 
  def validate(self):
25760 
    return
25761 
 
25762 
 
25763 
  def __repr__(self):
25764 
    L = ['%s=%r' % (key, value)
25765 
      for key, value in self.__dict__.iteritems()]
25766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25767 
 
25768 
  def __eq__(self, other):
25769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25770 
 
25771 
  def __ne__(self, other):
25772 
    return not (self == other)
25773 
 
25774 
class getAllFlipkartItems_result:
25775 
  """
25776 
  Attributes:
25777 
   - success
25778 
  """
25779 
 
25780 
  thrift_spec = (
25781 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
25782 
  )
25783 
 
25784 
  def __init__(self, success=None,):
25785 
    self.success = success
25786 
 
25787 
  def read(self, iprot):
25788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25790 
      return
25791 
    iprot.readStructBegin()
25792 
    while True:
25793 
      (fname, ftype, fid) = iprot.readFieldBegin()
25794 
      if ftype == TType.STOP:
25795 
        break
25796 
      if fid == 0:
25797 
        if ftype == TType.LIST:
25798 
          self.success = []
25799 
          (_etype581, _size578) = iprot.readListBegin()
25800 
          for _i582 in xrange(_size578):
25801 
            _elem583 = FlipkartItem()
25802 
            _elem583.read(iprot)
25803 
            self.success.append(_elem583)
25804 
          iprot.readListEnd()
25805 
        else:
25806 
          iprot.skip(ftype)
25807 
      else:
25808 
        iprot.skip(ftype)
25809 
      iprot.readFieldEnd()
25810 
    iprot.readStructEnd()
25811 
 
25812 
  def write(self, oprot):
25813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25815 
      return
25816 
    oprot.writeStructBegin('getAllFlipkartItems_result')
25817 
    if self.success is not None:
25818 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25819 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25820 
      for iter584 in self.success:
25821 
        iter584.write(oprot)
25822 
      oprot.writeListEnd()
25823 
      oprot.writeFieldEnd()
25824 
    oprot.writeFieldStop()
25825 
    oprot.writeStructEnd()
25826 
 
25827 
  def validate(self):
25828 
    return
25829 
 
25830 
 
25831 
  def __repr__(self):
25832 
    L = ['%s=%r' % (key, value)
25833 
      for key, value in self.__dict__.iteritems()]
25834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25835 
 
25836 
  def __eq__(self, other):
25837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25838 
 
25839 
  def __ne__(self, other):
25840 
    return not (self == other)