Subversion Repositories SmartDukaan

Rev

Rev 9816 | Rev 9895 | 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 
 
9861 rajveer 1044 
 
5944 mandeep.dh 1045 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1046 
  def __init__(self, iprot, oprot=None):
1047 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1048 
 
1049 
  def addItem(self, item):
1050 
    """
1051 
    Availability and inventory attributes
1052 
 
1053 
    Parameters:
1054 
     - item
1055 
    """
1056 
    self.send_addItem(item)
1057 
    return self.recv_addItem()
1058 
 
1059 
  def send_addItem(self, item):
1060 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1061 
    args = addItem_args()
1062 
    args.item = item
1063 
    args.write(self._oprot)
1064 
    self._oprot.writeMessageEnd()
1065 
    self._oprot.trans.flush()
1066 
 
1067 
  def recv_addItem(self, ):
1068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1069 
    if mtype == TMessageType.EXCEPTION:
1070 
      x = TApplicationException()
1071 
      x.read(self._iprot)
1072 
      self._iprot.readMessageEnd()
1073 
      raise x
1074 
    result = addItem_result()
1075 
    result.read(self._iprot)
1076 
    self._iprot.readMessageEnd()
1077 
    if result.success is not None:
1078 
      return result.success
1079 
    if result.cex is not None:
1080 
      raise result.cex
1081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1082 
 
1083 
  def updateItem(self, item):
1084 
    """
1085 
    Parameters:
1086 
     - item
1087 
    """
1088 
    self.send_updateItem(item)
1089 
    return self.recv_updateItem()
1090 
 
1091 
  def send_updateItem(self, item):
1092 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1093 
    args = updateItem_args()
1094 
    args.item = item
1095 
    args.write(self._oprot)
1096 
    self._oprot.writeMessageEnd()
1097 
    self._oprot.trans.flush()
1098 
 
1099 
  def recv_updateItem(self, ):
1100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1101 
    if mtype == TMessageType.EXCEPTION:
1102 
      x = TApplicationException()
1103 
      x.read(self._iprot)
1104 
      self._iprot.readMessageEnd()
1105 
      raise x
1106 
    result = updateItem_result()
1107 
    result.read(self._iprot)
1108 
    self._iprot.readMessageEnd()
1109 
    if result.success is not None:
1110 
      return result.success
1111 
    if result.cex is not None:
1112 
      raise result.cex
1113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1114 
 
1115 
  def isActive(self, itemId):
1116 
    """
1117 
    Checks if the item given to the corresponding itemId is active. If it's active,
1118 
    whether it's risky and if it's risky, its inventory position.
1119 
 
1120 
    Parameters:
1121 
     - itemId
1122 
    """
1123 
    self.send_isActive(itemId)
1124 
    return self.recv_isActive()
1125 
 
1126 
  def send_isActive(self, itemId):
1127 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1128 
    args = isActive_args()
1129 
    args.itemId = itemId
1130 
    args.write(self._oprot)
1131 
    self._oprot.writeMessageEnd()
1132 
    self._oprot.trans.flush()
1133 
 
1134 
  def recv_isActive(self, ):
1135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1136 
    if mtype == TMessageType.EXCEPTION:
1137 
      x = TApplicationException()
1138 
      x.read(self._iprot)
1139 
      self._iprot.readMessageEnd()
1140 
      raise x
1141 
    result = isActive_result()
1142 
    result.read(self._iprot)
1143 
    self._iprot.readMessageEnd()
1144 
    if result.success is not None:
1145 
      return result.success
1146 
    if result.isex is not None:
1147 
      raise result.isex
1148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1149 
 
7438 amit.gupta 1150 
  def getItemsStatus(self, itemIds):
1151 
    """
1152 
    Parameters:
1153 
     - itemIds
1154 
    """
1155 
    self.send_getItemsStatus(itemIds)
1156 
    return self.recv_getItemsStatus()
1157 
 
1158 
  def send_getItemsStatus(self, itemIds):
1159 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1160 
    args = getItemsStatus_args()
1161 
    args.itemIds = itemIds
1162 
    args.write(self._oprot)
1163 
    self._oprot.writeMessageEnd()
1164 
    self._oprot.trans.flush()
1165 
 
1166 
  def recv_getItemsStatus(self, ):
1167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1168 
    if mtype == TMessageType.EXCEPTION:
1169 
      x = TApplicationException()
1170 
      x.read(self._iprot)
1171 
      self._iprot.readMessageEnd()
1172 
      raise x
1173 
    result = getItemsStatus_result()
1174 
    result.read(self._iprot)
1175 
    self._iprot.readMessageEnd()
1176 
    if result.success is not None:
1177 
      return result.success
1178 
    if result.isex is not None:
1179 
      raise result.isex
1180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1181 
 
5944 mandeep.dh 1182 
  def getItemStatusDescription(self, itemId):
1183 
    """
1184 
    Parameters:
1185 
     - itemId
1186 
    """
1187 
    self.send_getItemStatusDescription(itemId)
1188 
    return self.recv_getItemStatusDescription()
1189 
 
1190 
  def send_getItemStatusDescription(self, itemId):
1191 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1192 
    args = getItemStatusDescription_args()
1193 
    args.itemId = itemId
1194 
    args.write(self._oprot)
1195 
    self._oprot.writeMessageEnd()
1196 
    self._oprot.trans.flush()
1197 
 
1198 
  def recv_getItemStatusDescription(self, ):
1199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1200 
    if mtype == TMessageType.EXCEPTION:
1201 
      x = TApplicationException()
1202 
      x.read(self._iprot)
1203 
      self._iprot.readMessageEnd()
1204 
      raise x
1205 
    result = getItemStatusDescription_result()
1206 
    result.read(self._iprot)
1207 
    self._iprot.readMessageEnd()
1208 
    if result.success is not None:
1209 
      return result.success
1210 
    if result.isex is not None:
1211 
      raise result.isex
1212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1213 
 
1214 
  def startItemOn(self, item_id, timestamp):
1215 
    """
1216 
    Parameters:
1217 
     - item_id
1218 
     - timestamp
1219 
    """
1220 
    self.send_startItemOn(item_id, timestamp)
1221 
    self.recv_startItemOn()
1222 
 
1223 
  def send_startItemOn(self, item_id, timestamp):
1224 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1225 
    args = startItemOn_args()
1226 
    args.item_id = item_id
1227 
    args.timestamp = timestamp
1228 
    args.write(self._oprot)
1229 
    self._oprot.writeMessageEnd()
1230 
    self._oprot.trans.flush()
1231 
 
1232 
  def recv_startItemOn(self, ):
1233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1234 
    if mtype == TMessageType.EXCEPTION:
1235 
      x = TApplicationException()
1236 
      x.read(self._iprot)
1237 
      self._iprot.readMessageEnd()
1238 
      raise x
1239 
    result = startItemOn_result()
1240 
    result.read(self._iprot)
1241 
    self._iprot.readMessageEnd()
1242 
    if result.cex is not None:
1243 
      raise result.cex
1244 
    return
1245 
 
1246 
  def retireItemOn(self, item_id, timestamp):
1247 
    """
1248 
    Parameters:
1249 
     - item_id
1250 
     - timestamp
1251 
    """
1252 
    self.send_retireItemOn(item_id, timestamp)
1253 
    self.recv_retireItemOn()
1254 
 
1255 
  def send_retireItemOn(self, item_id, timestamp):
1256 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1257 
    args = retireItemOn_args()
1258 
    args.item_id = item_id
1259 
    args.timestamp = timestamp
1260 
    args.write(self._oprot)
1261 
    self._oprot.writeMessageEnd()
1262 
    self._oprot.trans.flush()
1263 
 
1264 
  def recv_retireItemOn(self, ):
1265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1266 
    if mtype == TMessageType.EXCEPTION:
1267 
      x = TApplicationException()
1268 
      x.read(self._iprot)
1269 
      self._iprot.readMessageEnd()
1270 
      raise x
1271 
    result = retireItemOn_result()
1272 
    result.read(self._iprot)
1273 
    self._iprot.readMessageEnd()
1274 
    if result.cex is not None:
1275 
      raise result.cex
1276 
    return
1277 
 
1278 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1279 
    """
1280 
    Parameters:
1281 
     - item_id
1282 
     - timestamp
1283 
     - newstatus
1284 
    """
1285 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1286 
    self.recv_changeItemStatus()
1287 
 
1288 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1289 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1290 
    args = changeItemStatus_args()
1291 
    args.item_id = item_id
1292 
    args.timestamp = timestamp
1293 
    args.newstatus = newstatus
1294 
    args.write(self._oprot)
1295 
    self._oprot.writeMessageEnd()
1296 
    self._oprot.trans.flush()
1297 
 
1298 
  def recv_changeItemStatus(self, ):
1299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1300 
    if mtype == TMessageType.EXCEPTION:
1301 
      x = TApplicationException()
1302 
      x.read(self._iprot)
1303 
      self._iprot.readMessageEnd()
1304 
      raise x
1305 
    result = changeItemStatus_result()
1306 
    result.read(self._iprot)
1307 
    self._iprot.readMessageEnd()
1308 
    if result.cex is not None:
1309 
      raise result.cex
1310 
    return
1311 
 
1312 
  def getItem(self, item_id):
1313 
    """
1314 
    Parameters:
1315 
     - item_id
1316 
    """
1317 
    self.send_getItem(item_id)
1318 
    return self.recv_getItem()
1319 
 
1320 
  def send_getItem(self, item_id):
1321 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1322 
    args = getItem_args()
1323 
    args.item_id = item_id
1324 
    args.write(self._oprot)
1325 
    self._oprot.writeMessageEnd()
1326 
    self._oprot.trans.flush()
1327 
 
1328 
  def recv_getItem(self, ):
1329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1330 
    if mtype == TMessageType.EXCEPTION:
1331 
      x = TApplicationException()
1332 
      x.read(self._iprot)
1333 
      self._iprot.readMessageEnd()
1334 
      raise x
1335 
    result = getItem_result()
1336 
    result.read(self._iprot)
1337 
    self._iprot.readMessageEnd()
1338 
    if result.success is not None:
1339 
      return result.success
1340 
    if result.cex is not None:
1341 
      raise result.cex
1342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1343 
 
1344 
  def getItemsByCatalogId(self, catalog_item_id):
1345 
    """
1346 
    Parameters:
1347 
     - catalog_item_id
1348 
    """
1349 
    self.send_getItemsByCatalogId(catalog_item_id)
1350 
    return self.recv_getItemsByCatalogId()
1351 
 
1352 
  def send_getItemsByCatalogId(self, catalog_item_id):
1353 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1354 
    args = getItemsByCatalogId_args()
1355 
    args.catalog_item_id = catalog_item_id
1356 
    args.write(self._oprot)
1357 
    self._oprot.writeMessageEnd()
1358 
    self._oprot.trans.flush()
1359 
 
1360 
  def recv_getItemsByCatalogId(self, ):
1361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1362 
    if mtype == TMessageType.EXCEPTION:
1363 
      x = TApplicationException()
1364 
      x.read(self._iprot)
1365 
      self._iprot.readMessageEnd()
1366 
      raise x
1367 
    result = getItemsByCatalogId_result()
1368 
    result.read(self._iprot)
1369 
    self._iprot.readMessageEnd()
1370 
    if result.success is not None:
1371 
      return result.success
1372 
    if result.cex is not None:
1373 
      raise result.cex
1374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1375 
 
1376 
  def getValidItemsByCatalogId(self, catalog_item_id):
1377 
    """
1378 
    Parameters:
1379 
     - catalog_item_id
1380 
    """
1381 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1382 
    return self.recv_getValidItemsByCatalogId()
1383 
 
1384 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1385 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1386 
    args = getValidItemsByCatalogId_args()
1387 
    args.catalog_item_id = catalog_item_id
1388 
    args.write(self._oprot)
1389 
    self._oprot.writeMessageEnd()
1390 
    self._oprot.trans.flush()
1391 
 
1392 
  def recv_getValidItemsByCatalogId(self, ):
1393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1394 
    if mtype == TMessageType.EXCEPTION:
1395 
      x = TApplicationException()
1396 
      x.read(self._iprot)
1397 
      self._iprot.readMessageEnd()
1398 
      raise x
1399 
    result = getValidItemsByCatalogId_result()
1400 
    result.read(self._iprot)
1401 
    self._iprot.readMessageEnd()
1402 
    if result.success is not None:
1403 
      return result.success
1404 
    if result.cex is not None:
1405 
      raise result.cex
1406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1407 
 
1408 
  def getAllItems(self, isActive):
1409 
    """
1410 
    Parameters:
1411 
     - isActive
1412 
    """
1413 
    self.send_getAllItems(isActive)
1414 
    return self.recv_getAllItems()
1415 
 
1416 
  def send_getAllItems(self, isActive):
1417 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1418 
    args = getAllItems_args()
1419 
    args.isActive = isActive
1420 
    args.write(self._oprot)
1421 
    self._oprot.writeMessageEnd()
1422 
    self._oprot.trans.flush()
1423 
 
1424 
  def recv_getAllItems(self, ):
1425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1426 
    if mtype == TMessageType.EXCEPTION:
1427 
      x = TApplicationException()
1428 
      x.read(self._iprot)
1429 
      self._iprot.readMessageEnd()
1430 
      raise x
1431 
    result = getAllItems_result()
1432 
    result.read(self._iprot)
1433 
    self._iprot.readMessageEnd()
1434 
    if result.success is not None:
1435 
      return result.success
1436 
    if result.cex is not None:
1437 
      raise result.cex
1438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1439 
 
1440 
  def getAllItemsByStatus(self, itemStatus):
1441 
    """
1442 
    Parameters:
1443 
     - itemStatus
1444 
    """
1445 
    self.send_getAllItemsByStatus(itemStatus)
1446 
    return self.recv_getAllItemsByStatus()
1447 
 
1448 
  def send_getAllItemsByStatus(self, itemStatus):
1449 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1450 
    args = getAllItemsByStatus_args()
1451 
    args.itemStatus = itemStatus
1452 
    args.write(self._oprot)
1453 
    self._oprot.writeMessageEnd()
1454 
    self._oprot.trans.flush()
1455 
 
1456 
  def recv_getAllItemsByStatus(self, ):
1457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1458 
    if mtype == TMessageType.EXCEPTION:
1459 
      x = TApplicationException()
1460 
      x.read(self._iprot)
1461 
      self._iprot.readMessageEnd()
1462 
      raise x
1463 
    result = getAllItemsByStatus_result()
1464 
    result.read(self._iprot)
1465 
    self._iprot.readMessageEnd()
1466 
    if result.success is not None:
1467 
      return result.success
1468 
    if result.cex is not None:
1469 
      raise result.cex
1470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1471 
 
9253 rajveer 1472 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1473 
    """
1474 
    Parameters:
1475 
     - entityId
1476 
     - category
1477 
     - brand
1478 
     - modelName
1479 
     - modelNumber
9253 rajveer 1480 
     - isAndroid
5944 mandeep.dh 1481 
    """
9253 rajveer 1482 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1483 
    return self.recv_markItemAsContentComplete()
1484 
 
9253 rajveer 1485 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1486 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1487 
    args = markItemAsContentComplete_args()
1488 
    args.entityId = entityId
1489 
    args.category = category
1490 
    args.brand = brand
1491 
    args.modelName = modelName
1492 
    args.modelNumber = modelNumber
9253 rajveer 1493 
    args.isAndroid = isAndroid
5944 mandeep.dh 1494 
    args.write(self._oprot)
1495 
    self._oprot.writeMessageEnd()
1496 
    self._oprot.trans.flush()
1497 
 
1498 
  def recv_markItemAsContentComplete(self, ):
1499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1500 
    if mtype == TMessageType.EXCEPTION:
1501 
      x = TApplicationException()
1502 
      x.read(self._iprot)
1503 
      self._iprot.readMessageEnd()
1504 
      raise x
1505 
    result = markItemAsContentComplete_result()
1506 
    result.read(self._iprot)
1507 
    self._iprot.readMessageEnd()
1508 
    if result.success is not None:
1509 
      return result.success
1510 
    if result.cex is not None:
1511 
      raise result.cex
1512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1513 
 
1514 
  def getAllItemsInRange(self, offset, limit):
1515 
    """
1516 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1517 
 
1518 
    Parameters:
1519 
     - offset
1520 
     - limit
1521 
    """
1522 
    self.send_getAllItemsInRange(offset, limit)
1523 
    return self.recv_getAllItemsInRange()
1524 
 
1525 
  def send_getAllItemsInRange(self, offset, limit):
1526 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1527 
    args = getAllItemsInRange_args()
1528 
    args.offset = offset
1529 
    args.limit = limit
1530 
    args.write(self._oprot)
1531 
    self._oprot.writeMessageEnd()
1532 
    self._oprot.trans.flush()
1533 
 
1534 
  def recv_getAllItemsInRange(self, ):
1535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1536 
    if mtype == TMessageType.EXCEPTION:
1537 
      x = TApplicationException()
1538 
      x.read(self._iprot)
1539 
      self._iprot.readMessageEnd()
1540 
      raise x
1541 
    result = getAllItemsInRange_result()
1542 
    result.read(self._iprot)
1543 
    self._iprot.readMessageEnd()
1544 
    if result.success is not None:
1545 
      return result.success
1546 
    if result.cex is not None:
1547 
      raise result.cex
1548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1549 
 
1550 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1551 
    """
1552 
    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.
1553 
 
1554 
    Parameters:
1555 
     - itemStatus
1556 
     - offset
1557 
     - limit
1558 
    """
1559 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1560 
    return self.recv_getAllItemsByStatusInRange()
1561 
 
1562 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1563 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1564 
    args = getAllItemsByStatusInRange_args()
1565 
    args.itemStatus = itemStatus
1566 
    args.offset = offset
1567 
    args.limit = limit
1568 
    args.write(self._oprot)
1569 
    self._oprot.writeMessageEnd()
1570 
    self._oprot.trans.flush()
1571 
 
1572 
  def recv_getAllItemsByStatusInRange(self, ):
1573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1574 
    if mtype == TMessageType.EXCEPTION:
1575 
      x = TApplicationException()
1576 
      x.read(self._iprot)
1577 
      self._iprot.readMessageEnd()
1578 
      raise x
1579 
    result = getAllItemsByStatusInRange_result()
1580 
    result.read(self._iprot)
1581 
    self._iprot.readMessageEnd()
1582 
    if result.success is not None:
1583 
      return result.success
1584 
    if result.cex is not None:
1585 
      raise result.cex
1586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1587 
 
1588 
  def getItemCountByStatus(self, useStatus, itemStatus):
1589 
    """
1590 
    Gets a count of all items by status
1591 
 
1592 
    Parameters:
1593 
     - useStatus
1594 
     - itemStatus
1595 
    """
1596 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1597 
    return self.recv_getItemCountByStatus()
1598 
 
1599 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1600 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1601 
    args = getItemCountByStatus_args()
1602 
    args.useStatus = useStatus
1603 
    args.itemStatus = itemStatus
1604 
    args.write(self._oprot)
1605 
    self._oprot.writeMessageEnd()
1606 
    self._oprot.trans.flush()
1607 
 
1608 
  def recv_getItemCountByStatus(self, ):
1609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1610 
    if mtype == TMessageType.EXCEPTION:
1611 
      x = TApplicationException()
1612 
      x.read(self._iprot)
1613 
      self._iprot.readMessageEnd()
1614 
      raise x
1615 
    result = getItemCountByStatus_result()
1616 
    result.read(self._iprot)
1617 
    self._iprot.readMessageEnd()
1618 
    if result.success is not None:
1619 
      return result.success
1620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1621 
 
1622 
  def getBestSellers(self, ):
1623 
    self.send_getBestSellers()
1624 
    return self.recv_getBestSellers()
1625 
 
1626 
  def send_getBestSellers(self, ):
1627 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1628 
    args = getBestSellers_args()
1629 
    args.write(self._oprot)
1630 
    self._oprot.writeMessageEnd()
1631 
    self._oprot.trans.flush()
1632 
 
1633 
  def recv_getBestSellers(self, ):
1634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1635 
    if mtype == TMessageType.EXCEPTION:
1636 
      x = TApplicationException()
1637 
      x.read(self._iprot)
1638 
      self._iprot.readMessageEnd()
1639 
      raise x
1640 
    result = getBestSellers_result()
1641 
    result.read(self._iprot)
1642 
    self._iprot.readMessageEnd()
1643 
    if result.success is not None:
1644 
      return result.success
1645 
    if result.isex is not None:
1646 
      raise result.isex
1647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1648 
 
1649 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1650 
    """
1651 
    Parameters:
1652 
     - beginIndex
1653 
     - totalItems
1654 
     - brand
1655 
     - category
1656 
    """
1657 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1658 
    return self.recv_getBestSellersCatalogIds()
1659 
 
1660 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1661 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1662 
    args = getBestSellersCatalogIds_args()
1663 
    args.beginIndex = beginIndex
1664 
    args.totalItems = totalItems
1665 
    args.brand = brand
1666 
    args.category = category
1667 
    args.write(self._oprot)
1668 
    self._oprot.writeMessageEnd()
1669 
    self._oprot.trans.flush()
1670 
 
1671 
  def recv_getBestSellersCatalogIds(self, ):
1672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1673 
    if mtype == TMessageType.EXCEPTION:
1674 
      x = TApplicationException()
1675 
      x.read(self._iprot)
1676 
      self._iprot.readMessageEnd()
1677 
      raise x
1678 
    result = getBestSellersCatalogIds_result()
1679 
    result.read(self._iprot)
1680 
    self._iprot.readMessageEnd()
1681 
    if result.success is not None:
1682 
      return result.success
1683 
    if result.cex is not None:
1684 
      raise result.cex
1685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1686 
 
1687 
  def getBestSellersCount(self, ):
1688 
    self.send_getBestSellersCount()
1689 
    return self.recv_getBestSellersCount()
1690 
 
1691 
  def send_getBestSellersCount(self, ):
1692 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1693 
    args = getBestSellersCount_args()
1694 
    args.write(self._oprot)
1695 
    self._oprot.writeMessageEnd()
1696 
    self._oprot.trans.flush()
1697 
 
1698 
  def recv_getBestSellersCount(self, ):
1699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1700 
    if mtype == TMessageType.EXCEPTION:
1701 
      x = TApplicationException()
1702 
      x.read(self._iprot)
1703 
      self._iprot.readMessageEnd()
1704 
      raise x
1705 
    result = getBestSellersCount_result()
1706 
    result.read(self._iprot)
1707 
    self._iprot.readMessageEnd()
1708 
    if result.success is not None:
1709 
      return result.success
1710 
    if result.cex is not None:
1711 
      raise result.cex
1712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1713 
 
1714 
  def getBestDeals(self, ):
1715 
    self.send_getBestDeals()
1716 
    return self.recv_getBestDeals()
1717 
 
1718 
  def send_getBestDeals(self, ):
1719 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1720 
    args = getBestDeals_args()
1721 
    args.write(self._oprot)
1722 
    self._oprot.writeMessageEnd()
1723 
    self._oprot.trans.flush()
1724 
 
1725 
  def recv_getBestDeals(self, ):
1726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1727 
    if mtype == TMessageType.EXCEPTION:
1728 
      x = TApplicationException()
1729 
      x.read(self._iprot)
1730 
      self._iprot.readMessageEnd()
1731 
      raise x
1732 
    result = getBestDeals_result()
1733 
    result.read(self._iprot)
1734 
    self._iprot.readMessageEnd()
1735 
    if result.success is not None:
1736 
      return result.success
1737 
    if result.isex is not None:
1738 
      raise result.isex
1739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1740 
 
1741 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1742 
    """
1743 
    Parameters:
1744 
     - beginIndex
1745 
     - totalItems
1746 
     - brand
1747 
     - category
1748 
    """
1749 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1750 
    return self.recv_getBestDealsCatalogIds()
1751 
 
1752 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1753 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1754 
    args = getBestDealsCatalogIds_args()
1755 
    args.beginIndex = beginIndex
1756 
    args.totalItems = totalItems
1757 
    args.brand = brand
1758 
    args.category = category
1759 
    args.write(self._oprot)
1760 
    self._oprot.writeMessageEnd()
1761 
    self._oprot.trans.flush()
1762 
 
1763 
  def recv_getBestDealsCatalogIds(self, ):
1764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1765 
    if mtype == TMessageType.EXCEPTION:
1766 
      x = TApplicationException()
1767 
      x.read(self._iprot)
1768 
      self._iprot.readMessageEnd()
1769 
      raise x
1770 
    result = getBestDealsCatalogIds_result()
1771 
    result.read(self._iprot)
1772 
    self._iprot.readMessageEnd()
1773 
    if result.success is not None:
1774 
      return result.success
1775 
    if result.cex is not None:
1776 
      raise result.cex
1777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1778 
 
1779 
  def getBestDealsCount(self, ):
1780 
    self.send_getBestDealsCount()
1781 
    return self.recv_getBestDealsCount()
1782 
 
1783 
  def send_getBestDealsCount(self, ):
1784 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1785 
    args = getBestDealsCount_args()
1786 
    args.write(self._oprot)
1787 
    self._oprot.writeMessageEnd()
1788 
    self._oprot.trans.flush()
1789 
 
1790 
  def recv_getBestDealsCount(self, ):
1791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1792 
    if mtype == TMessageType.EXCEPTION:
1793 
      x = TApplicationException()
1794 
      x.read(self._iprot)
1795 
      self._iprot.readMessageEnd()
1796 
      raise x
1797 
    result = getBestDealsCount_result()
1798 
    result.read(self._iprot)
1799 
    self._iprot.readMessageEnd()
1800 
    if result.success is not None:
1801 
      return result.success
1802 
    if result.cex is not None:
1803 
      raise result.cex
1804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1805 
 
1806 
  def getComingSoon(self, ):
1807 
    self.send_getComingSoon()
1808 
    return self.recv_getComingSoon()
1809 
 
1810 
  def send_getComingSoon(self, ):
1811 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1812 
    args = getComingSoon_args()
1813 
    args.write(self._oprot)
1814 
    self._oprot.writeMessageEnd()
1815 
    self._oprot.trans.flush()
1816 
 
1817 
  def recv_getComingSoon(self, ):
1818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1819 
    if mtype == TMessageType.EXCEPTION:
1820 
      x = TApplicationException()
1821 
      x.read(self._iprot)
1822 
      self._iprot.readMessageEnd()
1823 
      raise x
1824 
    result = getComingSoon_result()
1825 
    result.read(self._iprot)
1826 
    self._iprot.readMessageEnd()
1827 
    if result.success is not None:
1828 
      return result.success
1829 
    if result.isex is not None:
1830 
      raise result.isex
1831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1832 
 
1833 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1834 
    """
1835 
    Parameters:
1836 
     - beginIndex
1837 
     - totalItems
1838 
     - brand
1839 
     - category
1840 
    """
1841 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1842 
    return self.recv_getComingSoonCatalogIds()
1843 
 
1844 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1845 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1846 
    args = getComingSoonCatalogIds_args()
1847 
    args.beginIndex = beginIndex
1848 
    args.totalItems = totalItems
1849 
    args.brand = brand
1850 
    args.category = category
1851 
    args.write(self._oprot)
1852 
    self._oprot.writeMessageEnd()
1853 
    self._oprot.trans.flush()
1854 
 
1855 
  def recv_getComingSoonCatalogIds(self, ):
1856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1857 
    if mtype == TMessageType.EXCEPTION:
1858 
      x = TApplicationException()
1859 
      x.read(self._iprot)
1860 
      self._iprot.readMessageEnd()
1861 
      raise x
1862 
    result = getComingSoonCatalogIds_result()
1863 
    result.read(self._iprot)
1864 
    self._iprot.readMessageEnd()
1865 
    if result.success is not None:
1866 
      return result.success
1867 
    if result.cex is not None:
1868 
      raise result.cex
1869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1870 
 
1871 
  def getComingSoonCount(self, ):
1872 
    self.send_getComingSoonCount()
1873 
    return self.recv_getComingSoonCount()
1874 
 
1875 
  def send_getComingSoonCount(self, ):
1876 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1877 
    args = getComingSoonCount_args()
1878 
    args.write(self._oprot)
1879 
    self._oprot.writeMessageEnd()
1880 
    self._oprot.trans.flush()
1881 
 
1882 
  def recv_getComingSoonCount(self, ):
1883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1884 
    if mtype == TMessageType.EXCEPTION:
1885 
      x = TApplicationException()
1886 
      x.read(self._iprot)
1887 
      self._iprot.readMessageEnd()
1888 
      raise x
1889 
    result = getComingSoonCount_result()
1890 
    result.read(self._iprot)
1891 
    self._iprot.readMessageEnd()
1892 
    if result.success is not None:
1893 
      return result.success
1894 
    if result.cex is not None:
1895 
      raise result.cex
1896 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1897 
 
1898 
  def getLatestArrivals(self, ):
1899 
    """
1900 
    Returns a list of items sorted in the descending order by start date.
1901 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1902 
    """
1903 
    self.send_getLatestArrivals()
1904 
    return self.recv_getLatestArrivals()
1905 
 
1906 
  def send_getLatestArrivals(self, ):
1907 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1908 
    args = getLatestArrivals_args()
1909 
    args.write(self._oprot)
1910 
    self._oprot.writeMessageEnd()
1911 
    self._oprot.trans.flush()
1912 
 
1913 
  def recv_getLatestArrivals(self, ):
1914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1915 
    if mtype == TMessageType.EXCEPTION:
1916 
      x = TApplicationException()
1917 
      x.read(self._iprot)
1918 
      self._iprot.readMessageEnd()
1919 
      raise x
1920 
    result = getLatestArrivals_result()
1921 
    result.read(self._iprot)
1922 
    self._iprot.readMessageEnd()
1923 
    if result.success is not None:
1924 
      return result.success
1925 
    if result.isex is not None:
1926 
      raise result.isex
1927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1928 
 
1929 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1930 
    """
1931 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1932 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1933 
 
1934 
    Parameters:
1935 
     - beginIndex
1936 
     - totalItems
1937 
     - brand
1938 
     - categories
1939 
    """
1940 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1941 
    return self.recv_getLatestArrivalsCatalogIds()
1942 
 
1943 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1944 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1945 
    args = getLatestArrivalsCatalogIds_args()
1946 
    args.beginIndex = beginIndex
1947 
    args.totalItems = totalItems
1948 
    args.brand = brand
1949 
    args.categories = categories
1950 
    args.write(self._oprot)
1951 
    self._oprot.writeMessageEnd()
1952 
    self._oprot.trans.flush()
1953 
 
1954 
  def recv_getLatestArrivalsCatalogIds(self, ):
1955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1956 
    if mtype == TMessageType.EXCEPTION:
1957 
      x = TApplicationException()
1958 
      x.read(self._iprot)
1959 
      self._iprot.readMessageEnd()
1960 
      raise x
1961 
    result = getLatestArrivalsCatalogIds_result()
1962 
    result.read(self._iprot)
1963 
    self._iprot.readMessageEnd()
1964 
    if result.success is not None:
1965 
      return result.success
1966 
    if result.cex is not None:
1967 
      raise result.cex
1968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1969 
 
1970 
  def getLatestArrivalsCount(self, ):
1971 
    """
1972 
    Get the total number of latest arrivals we are willing to show.
1973 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1974 
    """
1975 
    self.send_getLatestArrivalsCount()
1976 
    return self.recv_getLatestArrivalsCount()
1977 
 
1978 
  def send_getLatestArrivalsCount(self, ):
1979 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1980 
    args = getLatestArrivalsCount_args()
1981 
    args.write(self._oprot)
1982 
    self._oprot.writeMessageEnd()
1983 
    self._oprot.trans.flush()
1984 
 
1985 
  def recv_getLatestArrivalsCount(self, ):
1986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1987 
    if mtype == TMessageType.EXCEPTION:
1988 
      x = TApplicationException()
1989 
      x.read(self._iprot)
1990 
      self._iprot.readMessageEnd()
1991 
      raise x
1992 
    result = getLatestArrivalsCount_result()
1993 
    result.read(self._iprot)
1994 
    self._iprot.readMessageEnd()
1995 
    if result.success is not None:
1996 
      return result.success
1997 
    if result.cex is not None:
1998 
      raise result.cex
1999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
2000 
 
2001 
  def generateNewEntityID(self, ):
2002 
    self.send_generateNewEntityID()
2003 
    return self.recv_generateNewEntityID()
2004 
 
2005 
  def send_generateNewEntityID(self, ):
2006 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2007 
    args = generateNewEntityID_args()
2008 
    args.write(self._oprot)
2009 
    self._oprot.writeMessageEnd()
2010 
    self._oprot.trans.flush()
2011 
 
2012 
  def recv_generateNewEntityID(self, ):
2013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2014 
    if mtype == TMessageType.EXCEPTION:
2015 
      x = TApplicationException()
2016 
      x.read(self._iprot)
2017 
      self._iprot.readMessageEnd()
2018 
      raise x
2019 
    result = generateNewEntityID_result()
2020 
    result.read(self._iprot)
2021 
    self._iprot.readMessageEnd()
2022 
    if result.success is not None:
2023 
      return result.success
2024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2025 
 
2026 
  def addCategory(self, category):
2027 
    """
2028 
    All category related functions
2029 
 
2030 
    Parameters:
2031 
     - category
2032 
    """
2033 
    self.send_addCategory(category)
2034 
    return self.recv_addCategory()
2035 
 
2036 
  def send_addCategory(self, category):
2037 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2038 
    args = addCategory_args()
2039 
    args.category = category
2040 
    args.write(self._oprot)
2041 
    self._oprot.writeMessageEnd()
2042 
    self._oprot.trans.flush()
2043 
 
2044 
  def recv_addCategory(self, ):
2045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2046 
    if mtype == TMessageType.EXCEPTION:
2047 
      x = TApplicationException()
2048 
      x.read(self._iprot)
2049 
      self._iprot.readMessageEnd()
2050 
      raise x
2051 
    result = addCategory_result()
2052 
    result.read(self._iprot)
2053 
    self._iprot.readMessageEnd()
2054 
    if result.success is not None:
2055 
      return result.success
2056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2057 
 
2058 
  def getCategory(self, id):
2059 
    """
2060 
    Parameters:
2061 
     - id
2062 
    """
2063 
    self.send_getCategory(id)
2064 
    return self.recv_getCategory()
2065 
 
2066 
  def send_getCategory(self, id):
2067 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2068 
    args = getCategory_args()
2069 
    args.id = id
2070 
    args.write(self._oprot)
2071 
    self._oprot.writeMessageEnd()
2072 
    self._oprot.trans.flush()
2073 
 
2074 
  def recv_getCategory(self, ):
2075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2076 
    if mtype == TMessageType.EXCEPTION:
2077 
      x = TApplicationException()
2078 
      x.read(self._iprot)
2079 
      self._iprot.readMessageEnd()
2080 
      raise x
2081 
    result = getCategory_result()
2082 
    result.read(self._iprot)
2083 
    self._iprot.readMessageEnd()
2084 
    if result.success is not None:
2085 
      return result.success
2086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2087 
 
2088 
  def getAllCategories(self, ):
2089 
    self.send_getAllCategories()
2090 
    return self.recv_getAllCategories()
2091 
 
2092 
  def send_getAllCategories(self, ):
2093 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2094 
    args = getAllCategories_args()
2095 
    args.write(self._oprot)
2096 
    self._oprot.writeMessageEnd()
2097 
    self._oprot.trans.flush()
2098 
 
2099 
  def recv_getAllCategories(self, ):
2100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2101 
    if mtype == TMessageType.EXCEPTION:
2102 
      x = TApplicationException()
2103 
      x.read(self._iprot)
2104 
      self._iprot.readMessageEnd()
2105 
      raise x
2106 
    result = getAllCategories_result()
2107 
    result.read(self._iprot)
2108 
    self._iprot.readMessageEnd()
2109 
    if result.success is not None:
2110 
      return result.success
2111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2112 
 
2113 
  def getAllSimilarItems(self, itemId):
2114 
    """
2115 
    Returns the list of similar items.
2116 
 
2117 
    Parameters:
2118 
     - itemId
2119 
    """
2120 
    self.send_getAllSimilarItems(itemId)
2121 
    return self.recv_getAllSimilarItems()
2122 
 
2123 
  def send_getAllSimilarItems(self, itemId):
2124 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2125 
    args = getAllSimilarItems_args()
2126 
    args.itemId = itemId
2127 
    args.write(self._oprot)
2128 
    self._oprot.writeMessageEnd()
2129 
    self._oprot.trans.flush()
2130 
 
2131 
  def recv_getAllSimilarItems(self, ):
2132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2133 
    if mtype == TMessageType.EXCEPTION:
2134 
      x = TApplicationException()
2135 
      x.read(self._iprot)
2136 
      self._iprot.readMessageEnd()
2137 
      raise x
2138 
    result = getAllSimilarItems_result()
2139 
    result.read(self._iprot)
2140 
    self._iprot.readMessageEnd()
2141 
    if result.success is not None:
2142 
      return result.success
2143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2144 
 
2145 
  def addSimilarItem(self, itemId, catalogItemId):
2146 
    """
2147 
    Adds similar item.
2148 
 
2149 
    Parameters:
2150 
     - itemId
2151 
     - catalogItemId
2152 
    """
2153 
    self.send_addSimilarItem(itemId, catalogItemId)
2154 
    return self.recv_addSimilarItem()
2155 
 
2156 
  def send_addSimilarItem(self, itemId, catalogItemId):
2157 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2158 
    args = addSimilarItem_args()
2159 
    args.itemId = itemId
2160 
    args.catalogItemId = catalogItemId
2161 
    args.write(self._oprot)
2162 
    self._oprot.writeMessageEnd()
2163 
    self._oprot.trans.flush()
2164 
 
2165 
  def recv_addSimilarItem(self, ):
2166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2167 
    if mtype == TMessageType.EXCEPTION:
2168 
      x = TApplicationException()
2169 
      x.read(self._iprot)
2170 
      self._iprot.readMessageEnd()
2171 
      raise x
2172 
    result = addSimilarItem_result()
2173 
    result.read(self._iprot)
2174 
    self._iprot.readMessageEnd()
2175 
    if result.success is not None:
2176 
      return result.success
2177 
    if result.cex is not None:
2178 
      raise result.cex
2179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2180 
 
6512 kshitij.so 2181 
  def addTag(self, displayName, itemId):
2182 
    """
2183 
    Tag Related
2184 
 
2185 
    Parameters:
2186 
     - displayName
2187 
     - itemId
2188 
    """
2189 
    self.send_addTag(displayName, itemId)
2190 
    return self.recv_addTag()
2191 
 
2192 
  def send_addTag(self, displayName, itemId):
2193 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2194 
    args = addTag_args()
2195 
    args.displayName = displayName
2196 
    args.itemId = itemId
2197 
    args.write(self._oprot)
2198 
    self._oprot.writeMessageEnd()
2199 
    self._oprot.trans.flush()
2200 
 
2201 
  def recv_addTag(self, ):
2202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2203 
    if mtype == TMessageType.EXCEPTION:
2204 
      x = TApplicationException()
2205 
      x.read(self._iprot)
2206 
      self._iprot.readMessageEnd()
2207 
      raise x
2208 
    result = addTag_result()
2209 
    result.read(self._iprot)
2210 
    self._iprot.readMessageEnd()
2211 
    if result.success is not None:
2212 
      return result.success
2213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2214 
 
2215 
  def deleteEntityTag(self, displayName, itemId):
2216 
    """
2217 
    Parameters:
2218 
     - displayName
2219 
     - itemId
2220 
    """
2221 
    self.send_deleteEntityTag(displayName, itemId)
2222 
    return self.recv_deleteEntityTag()
2223 
 
2224 
  def send_deleteEntityTag(self, displayName, itemId):
2225 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2226 
    args = deleteEntityTag_args()
2227 
    args.displayName = displayName
2228 
    args.itemId = itemId
2229 
    args.write(self._oprot)
2230 
    self._oprot.writeMessageEnd()
2231 
    self._oprot.trans.flush()
2232 
 
2233 
  def recv_deleteEntityTag(self, ):
2234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2235 
    if mtype == TMessageType.EXCEPTION:
2236 
      x = TApplicationException()
2237 
      x.read(self._iprot)
2238 
      self._iprot.readMessageEnd()
2239 
      raise x
2240 
    result = deleteEntityTag_result()
2241 
    result.read(self._iprot)
2242 
    self._iprot.readMessageEnd()
2243 
    if result.success is not None:
2244 
      return result.success
2245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2246 
 
2247 
  def deleteTag(self, displayName):
2248 
    """
2249 
    Parameters:
2250 
     - displayName
2251 
    """
2252 
    self.send_deleteTag(displayName)
2253 
    return self.recv_deleteTag()
2254 
 
2255 
  def send_deleteTag(self, displayName):
2256 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2257 
    args = deleteTag_args()
2258 
    args.displayName = displayName
2259 
    args.write(self._oprot)
2260 
    self._oprot.writeMessageEnd()
2261 
    self._oprot.trans.flush()
2262 
 
2263 
  def recv_deleteTag(self, ):
2264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2265 
    if mtype == TMessageType.EXCEPTION:
2266 
      x = TApplicationException()
2267 
      x.read(self._iprot)
2268 
      self._iprot.readMessageEnd()
2269 
      raise x
2270 
    result = deleteTag_result()
2271 
    result.read(self._iprot)
2272 
    self._iprot.readMessageEnd()
2273 
    if result.success is not None:
2274 
      return result.success
2275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2276 
 
2277 
  def getAllTags(self, ):
2278 
    self.send_getAllTags()
2279 
    return self.recv_getAllTags()
2280 
 
2281 
  def send_getAllTags(self, ):
2282 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2283 
    args = getAllTags_args()
2284 
    args.write(self._oprot)
2285 
    self._oprot.writeMessageEnd()
2286 
    self._oprot.trans.flush()
2287 
 
2288 
  def recv_getAllTags(self, ):
2289 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2290 
    if mtype == TMessageType.EXCEPTION:
2291 
      x = TApplicationException()
2292 
      x.read(self._iprot)
2293 
      self._iprot.readMessageEnd()
2294 
      raise x
2295 
    result = getAllTags_result()
2296 
    result.read(self._iprot)
2297 
    self._iprot.readMessageEnd()
2298 
    if result.success is not None:
2299 
      return result.success
2300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2301 
 
2302 
  def getAllEntitiesByTagName(self, displayName):
2303 
    """
2304 
    Parameters:
2305 
     - displayName
2306 
    """
2307 
    self.send_getAllEntitiesByTagName(displayName)
2308 
    return self.recv_getAllEntitiesByTagName()
2309 
 
2310 
  def send_getAllEntitiesByTagName(self, displayName):
2311 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2312 
    args = getAllEntitiesByTagName_args()
2313 
    args.displayName = displayName
2314 
    args.write(self._oprot)
2315 
    self._oprot.writeMessageEnd()
2316 
    self._oprot.trans.flush()
2317 
 
2318 
  def recv_getAllEntitiesByTagName(self, ):
2319 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2320 
    if mtype == TMessageType.EXCEPTION:
2321 
      x = TApplicationException()
2322 
      x.read(self._iprot)
2323 
      self._iprot.readMessageEnd()
2324 
      raise x
2325 
    result = getAllEntitiesByTagName_result()
2326 
    result.read(self._iprot)
2327 
    self._iprot.readMessageEnd()
2328 
    if result.success is not None:
2329 
      return result.success
2330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2331 
 
6845 amit.gupta 2332 
  def getAllEntityTags(self, ):
2333 
    self.send_getAllEntityTags()
2334 
    return self.recv_getAllEntityTags()
2335 
 
2336 
  def send_getAllEntityTags(self, ):
2337 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2338 
    args = getAllEntityTags_args()
2339 
    args.write(self._oprot)
2340 
    self._oprot.writeMessageEnd()
2341 
    self._oprot.trans.flush()
2342 
 
2343 
  def recv_getAllEntityTags(self, ):
2344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2345 
    if mtype == TMessageType.EXCEPTION:
2346 
      x = TApplicationException()
2347 
      x.read(self._iprot)
2348 
      self._iprot.readMessageEnd()
2349 
      raise x
2350 
    result = getAllEntityTags_result()
2351 
    result.read(self._iprot)
2352 
    self._iprot.readMessageEnd()
2353 
    if result.success is not None:
2354 
      return result.success
2355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2356 
 
8590 kshitij.so 2357 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2358 
    """
8579 kshitij.so 2359 
    Banner Related
2360 
 
6850 kshitij.so 2361 
    Parameters:
8590 kshitij.so 2362 
     - bannerCongregate
6850 kshitij.so 2363 
    """
8590 kshitij.so 2364 
    self.send_addBanner(bannerCongregate)
2365 
    self.recv_addBanner()
6850 kshitij.so 2366 
 
8590 kshitij.so 2367 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2368 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2369 
    args = addBanner_args()
8590 kshitij.so 2370 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2371 
    args.write(self._oprot)
2372 
    self._oprot.writeMessageEnd()
2373 
    self._oprot.trans.flush()
2374 
 
2375 
  def recv_addBanner(self, ):
2376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2377 
    if mtype == TMessageType.EXCEPTION:
2378 
      x = TApplicationException()
2379 
      x.read(self._iprot)
2380 
      self._iprot.readMessageEnd()
2381 
      raise x
2382 
    result = addBanner_result()
2383 
    result.read(self._iprot)
2384 
    self._iprot.readMessageEnd()
8590 kshitij.so 2385 
    return
6850 kshitij.so 2386 
 
8579 kshitij.so 2387 
  def updateBanner(self, banner):
2388 
    """
2389 
    Parameters:
2390 
     - banner
2391 
    """
2392 
    self.send_updateBanner(banner)
2393 
    return self.recv_updateBanner()
2394 
 
2395 
  def send_updateBanner(self, banner):
2396 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2397 
    args = updateBanner_args()
2398 
    args.banner = banner
2399 
    args.write(self._oprot)
2400 
    self._oprot.writeMessageEnd()
2401 
    self._oprot.trans.flush()
2402 
 
2403 
  def recv_updateBanner(self, ):
2404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2405 
    if mtype == TMessageType.EXCEPTION:
2406 
      x = TApplicationException()
2407 
      x.read(self._iprot)
2408 
      self._iprot.readMessageEnd()
2409 
      raise x
2410 
    result = updateBanner_result()
2411 
    result.read(self._iprot)
2412 
    self._iprot.readMessageEnd()
2413 
    if result.success is not None:
2414 
      return result.success
2415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2416 
 
6850 kshitij.so 2417 
  def getAllBanners(self, ):
2418 
    self.send_getAllBanners()
2419 
    return self.recv_getAllBanners()
2420 
 
2421 
  def send_getAllBanners(self, ):
2422 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2423 
    args = getAllBanners_args()
2424 
    args.write(self._oprot)
2425 
    self._oprot.writeMessageEnd()
2426 
    self._oprot.trans.flush()
2427 
 
2428 
  def recv_getAllBanners(self, ):
2429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2430 
    if mtype == TMessageType.EXCEPTION:
2431 
      x = TApplicationException()
2432 
      x.read(self._iprot)
2433 
      self._iprot.readMessageEnd()
2434 
      raise x
2435 
    result = getAllBanners_result()
2436 
    result.read(self._iprot)
2437 
    self._iprot.readMessageEnd()
2438 
    if result.success is not None:
2439 
      return result.success
2440 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2441 
 
9155 kshitij.so 2442 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2443 
    """
2444 
    Parameters:
2445 
     - bannerName
9155 kshitij.so 2446 
     - bannerType
6850 kshitij.so 2447 
    """
9155 kshitij.so 2448 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2449 
    return self.recv_deleteBanner()
2450 
 
9155 kshitij.so 2451 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2452 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2453 
    args = deleteBanner_args()
2454 
    args.bannerName = bannerName
9155 kshitij.so 2455 
    args.bannerType = bannerType
6850 kshitij.so 2456 
    args.write(self._oprot)
2457 
    self._oprot.writeMessageEnd()
2458 
    self._oprot.trans.flush()
2459 
 
2460 
  def recv_deleteBanner(self, ):
2461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2462 
    if mtype == TMessageType.EXCEPTION:
2463 
      x = TApplicationException()
2464 
      x.read(self._iprot)
2465 
      self._iprot.readMessageEnd()
2466 
      raise x
2467 
    result = deleteBanner_result()
2468 
    result.read(self._iprot)
2469 
    self._iprot.readMessageEnd()
2470 
    if result.success is not None:
2471 
      return result.success
2472 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2473 
 
9155 kshitij.so 2474 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2475 
    """
2476 
    Parameters:
2477 
     - bannerName
9155 kshitij.so 2478 
     - bannerType
6850 kshitij.so 2479 
    """
9155 kshitij.so 2480 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2481 
    return self.recv_getBannerDetails()
2482 
 
9155 kshitij.so 2483 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2484 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2485 
    args = getBannerDetails_args()
2486 
    args.bannerName = bannerName
9155 kshitij.so 2487 
    args.bannerType = bannerType
6850 kshitij.so 2488 
    args.write(self._oprot)
2489 
    self._oprot.writeMessageEnd()
2490 
    self._oprot.trans.flush()
2491 
 
2492 
  def recv_getBannerDetails(self, ):
2493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2494 
    if mtype == TMessageType.EXCEPTION:
2495 
      x = TApplicationException()
2496 
      x.read(self._iprot)
2497 
      self._iprot.readMessageEnd()
2498 
      raise x
2499 
    result = getBannerDetails_result()
2500 
    result.read(self._iprot)
2501 
    self._iprot.readMessageEnd()
2502 
    if result.success is not None:
2503 
      return result.success
2504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2505 
 
2506 
  def getActiveBanners(self, ):
2507 
    self.send_getActiveBanners()
2508 
    return self.recv_getActiveBanners()
2509 
 
2510 
  def send_getActiveBanners(self, ):
2511 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2512 
    args = getActiveBanners_args()
2513 
    args.write(self._oprot)
2514 
    self._oprot.writeMessageEnd()
2515 
    self._oprot.trans.flush()
2516 
 
2517 
  def recv_getActiveBanners(self, ):
2518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2519 
    if mtype == TMessageType.EXCEPTION:
2520 
      x = TApplicationException()
2521 
      x.read(self._iprot)
2522 
      self._iprot.readMessageEnd()
2523 
      raise x
2524 
    result = getActiveBanners_result()
2525 
    result.read(self._iprot)
2526 
    self._iprot.readMessageEnd()
2527 
    if result.success is not None:
2528 
      return result.success
2529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2530 
 
8579 kshitij.so 2531 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2532 
    """
2533 
    Parameters:
8579 kshitij.so 2534 
     - bannerMaps
6849 kshitij.so 2535 
    """
8579 kshitij.so 2536 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2537 
    return self.recv_addBannerMap()
2538 
 
8579 kshitij.so 2539 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2540 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2541 
    args = addBannerMap_args()
8579 kshitij.so 2542 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2543 
    args.write(self._oprot)
2544 
    self._oprot.writeMessageEnd()
2545 
    self._oprot.trans.flush()
2546 
 
2547 
  def recv_addBannerMap(self, ):
2548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2549 
    if mtype == TMessageType.EXCEPTION:
2550 
      x = TApplicationException()
2551 
      x.read(self._iprot)
2552 
      self._iprot.readMessageEnd()
2553 
      raise x
2554 
    result = addBannerMap_result()
2555 
    result.read(self._iprot)
2556 
    self._iprot.readMessageEnd()
2557 
    if result.success is not None:
2558 
      return result.success
2559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2560 
 
8579 kshitij.so 2561 
  def updateBannerMap(self, bannerMap):
2562 
    """
2563 
    Parameters:
2564 
     - bannerMap
2565 
    """
2566 
    self.send_updateBannerMap(bannerMap)
2567 
    return self.recv_updateBannerMap()
2568 
 
2569 
  def send_updateBannerMap(self, bannerMap):
2570 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2571 
    args = updateBannerMap_args()
2572 
    args.bannerMap = bannerMap
2573 
    args.write(self._oprot)
2574 
    self._oprot.writeMessageEnd()
2575 
    self._oprot.trans.flush()
2576 
 
2577 
  def recv_updateBannerMap(self, ):
2578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2579 
    if mtype == TMessageType.EXCEPTION:
2580 
      x = TApplicationException()
2581 
      x.read(self._iprot)
2582 
      self._iprot.readMessageEnd()
2583 
      raise x
2584 
    result = updateBannerMap_result()
2585 
    result.read(self._iprot)
2586 
    self._iprot.readMessageEnd()
2587 
    if result.success is not None:
2588 
      return result.success
2589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2590 
 
6849 kshitij.so 2591 
  def deleteBannerMap(self, bannerName):
2592 
    """
2593 
    Parameters:
2594 
     - bannerName
2595 
    """
2596 
    self.send_deleteBannerMap(bannerName)
2597 
    return self.recv_deleteBannerMap()
2598 
 
2599 
  def send_deleteBannerMap(self, bannerName):
2600 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2601 
    args = deleteBannerMap_args()
2602 
    args.bannerName = bannerName
2603 
    args.write(self._oprot)
2604 
    self._oprot.writeMessageEnd()
2605 
    self._oprot.trans.flush()
2606 
 
2607 
  def recv_deleteBannerMap(self, ):
2608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2609 
    if mtype == TMessageType.EXCEPTION:
2610 
      x = TApplicationException()
2611 
      x.read(self._iprot)
2612 
      self._iprot.readMessageEnd()
2613 
      raise x
2614 
    result = deleteBannerMap_result()
2615 
    result.read(self._iprot)
2616 
    self._iprot.readMessageEnd()
2617 
    if result.success is not None:
2618 
      return result.success
2619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2620 
 
9155 kshitij.so 2621 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2622 
    """
2623 
    Parameters:
2624 
     - bannerName
9155 kshitij.so 2625 
     - bannerType
6849 kshitij.so 2626 
    """
9155 kshitij.so 2627 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2628 
    return self.recv_getBannerMapDetails()
2629 
 
9155 kshitij.so 2630 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2631 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2632 
    args = getBannerMapDetails_args()
2633 
    args.bannerName = bannerName
9155 kshitij.so 2634 
    args.bannerType = bannerType
6849 kshitij.so 2635 
    args.write(self._oprot)
2636 
    self._oprot.writeMessageEnd()
2637 
    self._oprot.trans.flush()
2638 
 
2639 
  def recv_getBannerMapDetails(self, ):
2640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2641 
    if mtype == TMessageType.EXCEPTION:
2642 
      x = TApplicationException()
2643 
      x.read(self._iprot)
2644 
      self._iprot.readMessageEnd()
2645 
      raise x
2646 
    result = getBannerMapDetails_result()
2647 
    result.read(self._iprot)
2648 
    self._iprot.readMessageEnd()
2649 
    if result.success is not None:
2650 
      return result.success
2651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2652 
 
8579 kshitij.so 2653 
  def addBannerUri(self, bannerUriMappings):
2654 
    """
2655 
    Parameters:
2656 
     - bannerUriMappings
2657 
    """
2658 
    self.send_addBannerUri(bannerUriMappings)
2659 
    self.recv_addBannerUri()
2660 
 
2661 
  def send_addBannerUri(self, bannerUriMappings):
2662 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2663 
    args = addBannerUri_args()
2664 
    args.bannerUriMappings = bannerUriMappings
2665 
    args.write(self._oprot)
2666 
    self._oprot.writeMessageEnd()
2667 
    self._oprot.trans.flush()
2668 
 
2669 
  def recv_addBannerUri(self, ):
2670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2671 
    if mtype == TMessageType.EXCEPTION:
2672 
      x = TApplicationException()
2673 
      x.read(self._iprot)
2674 
      self._iprot.readMessageEnd()
2675 
      raise x
2676 
    result = addBannerUri_result()
2677 
    result.read(self._iprot)
2678 
    self._iprot.readMessageEnd()
2679 
    return
2680 
 
9155 kshitij.so 2681 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2682 
    """
2683 
    Parameters:
2684 
     - bannerName
9155 kshitij.so 2685 
     - bannerType
8579 kshitij.so 2686 
    """
9155 kshitij.so 2687 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2688 
    return self.recv_getUriMapping()
2689 
 
9155 kshitij.so 2690 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2691 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2692 
    args = getUriMapping_args()
2693 
    args.bannerName = bannerName
9155 kshitij.so 2694 
    args.bannerType = bannerType
8579 kshitij.so 2695 
    args.write(self._oprot)
2696 
    self._oprot.writeMessageEnd()
2697 
    self._oprot.trans.flush()
2698 
 
2699 
  def recv_getUriMapping(self, ):
2700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2701 
    if mtype == TMessageType.EXCEPTION:
2702 
      x = TApplicationException()
2703 
      x.read(self._iprot)
2704 
      self._iprot.readMessageEnd()
2705 
      raise x
2706 
    result = getUriMapping_result()
2707 
    result.read(self._iprot)
2708 
    self._iprot.readMessageEnd()
2709 
    if result.success is not None:
2710 
      return result.success
2711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2712 
 
2713 
  def addCampaign(self, campaign):
2714 
    """
2715 
    Parameters:
2716 
     - campaign
2717 
    """
2718 
    self.send_addCampaign(campaign)
2719 
    self.recv_addCampaign()
2720 
 
2721 
  def send_addCampaign(self, campaign):
2722 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2723 
    args = addCampaign_args()
2724 
    args.campaign = campaign
2725 
    args.write(self._oprot)
2726 
    self._oprot.writeMessageEnd()
2727 
    self._oprot.trans.flush()
2728 
 
2729 
  def recv_addCampaign(self, ):
2730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2731 
    if mtype == TMessageType.EXCEPTION:
2732 
      x = TApplicationException()
2733 
      x.read(self._iprot)
2734 
      self._iprot.readMessageEnd()
2735 
      raise x
2736 
    result = addCampaign_result()
2737 
    result.read(self._iprot)
2738 
    self._iprot.readMessageEnd()
2739 
    return
2740 
 
2741 
  def getCampaigns(self, campaignName):
2742 
    """
2743 
    Parameters:
2744 
     - campaignName
2745 
    """
2746 
    self.send_getCampaigns(campaignName)
2747 
    return self.recv_getCampaigns()
2748 
 
2749 
  def send_getCampaigns(self, campaignName):
2750 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2751 
    args = getCampaigns_args()
2752 
    args.campaignName = campaignName
2753 
    args.write(self._oprot)
2754 
    self._oprot.writeMessageEnd()
2755 
    self._oprot.trans.flush()
2756 
 
2757 
  def recv_getCampaigns(self, ):
2758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2759 
    if mtype == TMessageType.EXCEPTION:
2760 
      x = TApplicationException()
2761 
      x.read(self._iprot)
2762 
      self._iprot.readMessageEnd()
2763 
      raise x
2764 
    result = getCampaigns_result()
2765 
    result.read(self._iprot)
2766 
    self._iprot.readMessageEnd()
2767 
    if result.success is not None:
2768 
      return result.success
2769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2770 
 
2771 
  def deleteCampaign(self, campaignId):
2772 
    """
2773 
    Parameters:
2774 
     - campaignId
2775 
    """
2776 
    self.send_deleteCampaign(campaignId)
2777 
    self.recv_deleteCampaign()
2778 
 
2779 
  def send_deleteCampaign(self, campaignId):
2780 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2781 
    args = deleteCampaign_args()
2782 
    args.campaignId = campaignId
2783 
    args.write(self._oprot)
2784 
    self._oprot.writeMessageEnd()
2785 
    self._oprot.trans.flush()
2786 
 
2787 
  def recv_deleteCampaign(self, ):
2788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2789 
    if mtype == TMessageType.EXCEPTION:
2790 
      x = TApplicationException()
2791 
      x.read(self._iprot)
2792 
      self._iprot.readMessageEnd()
2793 
      raise x
2794 
    result = deleteCampaign_result()
2795 
    result.read(self._iprot)
2796 
    self._iprot.readMessageEnd()
2797 
    return
2798 
 
2799 
  def getAllCampaigns(self, ):
2800 
    self.send_getAllCampaigns()
2801 
    return self.recv_getAllCampaigns()
2802 
 
2803 
  def send_getAllCampaigns(self, ):
2804 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2805 
    args = getAllCampaigns_args()
2806 
    args.write(self._oprot)
2807 
    self._oprot.writeMessageEnd()
2808 
    self._oprot.trans.flush()
2809 
 
2810 
  def recv_getAllCampaigns(self, ):
2811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2812 
    if mtype == TMessageType.EXCEPTION:
2813 
      x = TApplicationException()
2814 
      x.read(self._iprot)
2815 
      self._iprot.readMessageEnd()
2816 
      raise x
2817 
    result = getAllCampaigns_result()
2818 
    result.read(self._iprot)
2819 
    self._iprot.readMessageEnd()
2820 
    if result.success is not None:
2821 
      return result.success
2822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2823 
 
9155 kshitij.so 2824 
  def getActiveBannersForMobileSite(self, ):
2825 
    self.send_getActiveBannersForMobileSite()
2826 
    return self.recv_getActiveBannersForMobileSite()
2827 
 
2828 
  def send_getActiveBannersForMobileSite(self, ):
2829 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2830 
    args = getActiveBannersForMobileSite_args()
2831 
    args.write(self._oprot)
2832 
    self._oprot.writeMessageEnd()
2833 
    self._oprot.trans.flush()
2834 
 
2835 
  def recv_getActiveBannersForMobileSite(self, ):
2836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2837 
    if mtype == TMessageType.EXCEPTION:
2838 
      x = TApplicationException()
2839 
      x.read(self._iprot)
2840 
      self._iprot.readMessageEnd()
2841 
      raise x
2842 
    result = getActiveBannersForMobileSite_result()
2843 
    result.read(self._iprot)
2844 
    self._iprot.readMessageEnd()
2845 
    if result.success is not None:
2846 
      return result.success
2847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2848 
 
5944 mandeep.dh 2849 
  def deleteSimilarItem(self, itemId, catalogItemId):
2850 
    """
2851 
    Delete similar item.
2852 
 
2853 
    Parameters:
2854 
     - itemId
2855 
     - catalogItemId
2856 
    """
2857 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2858 
    return self.recv_deleteSimilarItem()
2859 
 
2860 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2861 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2862 
    args = deleteSimilarItem_args()
2863 
    args.itemId = itemId
2864 
    args.catalogItemId = catalogItemId
2865 
    args.write(self._oprot)
2866 
    self._oprot.writeMessageEnd()
2867 
    self._oprot.trans.flush()
2868 
 
2869 
  def recv_deleteSimilarItem(self, ):
2870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2871 
    if mtype == TMessageType.EXCEPTION:
2872 
      x = TApplicationException()
2873 
      x.read(self._iprot)
2874 
      self._iprot.readMessageEnd()
2875 
      raise x
2876 
    result = deleteSimilarItem_result()
2877 
    result.read(self._iprot)
2878 
    self._iprot.readMessageEnd()
2879 
    if result.success is not None:
2880 
      return result.success
2881 
    if result.cex is not None:
2882 
      raise result.cex
2883 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2884 
 
2885 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2886 
    """
2887 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2888 
    If yes, returns the itemId else returns 0
2889 
 
2890 
    Parameters:
2891 
     - brand
2892 
     - modelNumber
2893 
     - modelName
2894 
     - color
2895 
    """
2896 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2897 
    return self.recv_checkSimilarItem()
2898 
 
2899 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2900 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2901 
    args = checkSimilarItem_args()
2902 
    args.brand = brand
2903 
    args.modelNumber = modelNumber
2904 
    args.modelName = modelName
2905 
    args.color = color
2906 
    args.write(self._oprot)
2907 
    self._oprot.writeMessageEnd()
2908 
    self._oprot.trans.flush()
2909 
 
2910 
  def recv_checkSimilarItem(self, ):
2911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2912 
    if mtype == TMessageType.EXCEPTION:
2913 
      x = TApplicationException()
2914 
      x.read(self._iprot)
2915 
      self._iprot.readMessageEnd()
2916 
      raise x
2917 
    result = checkSimilarItem_result()
2918 
    result.read(self._iprot)
2919 
    self._iprot.readMessageEnd()
2920 
    if result.success is not None:
2921 
      return result.success
2922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2923 
 
2924 
  def validateRiskyStatus(self, itemId):
2925 
    """
2926 
    Check wether item is risky and change status if inventory is not available for risky items
2927 
 
2928 
    Parameters:
2929 
     - itemId
2930 
    """
2931 
    self.send_validateRiskyStatus(itemId)
2932 
    self.recv_validateRiskyStatus()
2933 
 
2934 
  def send_validateRiskyStatus(self, itemId):
2935 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2936 
    args = validateRiskyStatus_args()
2937 
    args.itemId = itemId
2938 
    args.write(self._oprot)
2939 
    self._oprot.writeMessageEnd()
2940 
    self._oprot.trans.flush()
2941 
 
2942 
  def recv_validateRiskyStatus(self, ):
2943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2944 
    if mtype == TMessageType.EXCEPTION:
2945 
      x = TApplicationException()
2946 
      x.read(self._iprot)
2947 
      self._iprot.readMessageEnd()
2948 
      raise x
2949 
    result = validateRiskyStatus_result()
2950 
    result.read(self._iprot)
2951 
    self._iprot.readMessageEnd()
2952 
    return
2953 
 
2954 
  def changeItemRiskyFlag(self, itemId, risky):
2955 
    """
2956 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2957 
 
2958 
    Parameters:
2959 
     - itemId
2960 
     - risky
2961 
    """
2962 
    self.send_changeItemRiskyFlag(itemId, risky)
2963 
    self.recv_changeItemRiskyFlag()
2964 
 
2965 
  def send_changeItemRiskyFlag(self, itemId, risky):
2966 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2967 
    args = changeItemRiskyFlag_args()
2968 
    args.itemId = itemId
2969 
    args.risky = risky
2970 
    args.write(self._oprot)
2971 
    self._oprot.writeMessageEnd()
2972 
    self._oprot.trans.flush()
2973 
 
2974 
  def recv_changeItemRiskyFlag(self, ):
2975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2976 
    if mtype == TMessageType.EXCEPTION:
2977 
      x = TApplicationException()
2978 
      x.read(self._iprot)
2979 
      self._iprot.readMessageEnd()
2980 
      raise x
2981 
    result = changeItemRiskyFlag_result()
2982 
    result.read(self._iprot)
2983 
    self._iprot.readMessageEnd()
2984 
    return
2985 
 
2986 
  def getItemsByRiskyFlag(self, ):
2987 
    """
2988 
    Returns list of items marked as risky.
2989 
    """
2990 
    self.send_getItemsByRiskyFlag()
2991 
    return self.recv_getItemsByRiskyFlag()
2992 
 
2993 
  def send_getItemsByRiskyFlag(self, ):
2994 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2995 
    args = getItemsByRiskyFlag_args()
2996 
    args.write(self._oprot)
2997 
    self._oprot.writeMessageEnd()
2998 
    self._oprot.trans.flush()
2999 
 
3000 
  def recv_getItemsByRiskyFlag(self, ):
3001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3002 
    if mtype == TMessageType.EXCEPTION:
3003 
      x = TApplicationException()
3004 
      x.read(self._iprot)
3005 
      self._iprot.readMessageEnd()
3006 
      raise x
3007 
    result = getItemsByRiskyFlag_result()
3008 
    result.read(self._iprot)
3009 
    self._iprot.readMessageEnd()
3010 
    if result.success is not None:
3011 
      return result.success
3012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
3013 
 
3014 
  def getItemsForMasterSheet(self, category, brand):
3015 
    """
3016 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3017 
 
3018 
    Parameters:
3019 
     - category
3020 
     - brand
3021 
    """
3022 
    self.send_getItemsForMasterSheet(category, brand)
3023 
    return self.recv_getItemsForMasterSheet()
3024 
 
3025 
  def send_getItemsForMasterSheet(self, category, brand):
3026 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3027 
    args = getItemsForMasterSheet_args()
3028 
    args.category = category
3029 
    args.brand = brand
3030 
    args.write(self._oprot)
3031 
    self._oprot.writeMessageEnd()
3032 
    self._oprot.trans.flush()
3033 
 
3034 
  def recv_getItemsForMasterSheet(self, ):
3035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3036 
    if mtype == TMessageType.EXCEPTION:
3037 
      x = TApplicationException()
3038 
      x.read(self._iprot)
3039 
      self._iprot.readMessageEnd()
3040 
      raise x
3041 
    result = getItemsForMasterSheet_result()
3042 
    result.read(self._iprot)
3043 
    self._iprot.readMessageEnd()
3044 
    if result.success is not None:
3045 
      return result.success
3046 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3047 
 
3048 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3049 
    """
3050 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3051 
 
3052 
    Parameters:
3053 
     - beginIndex
3054 
     - totalItems
3055 
     - itemId
3056 
    """
3057 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3058 
    return self.recv_getSimilarItemsCatalogIds()
3059 
 
3060 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3061 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3062 
    args = getSimilarItemsCatalogIds_args()
3063 
    args.beginIndex = beginIndex
3064 
    args.totalItems = totalItems
3065 
    args.itemId = itemId
3066 
    args.write(self._oprot)
3067 
    self._oprot.writeMessageEnd()
3068 
    self._oprot.trans.flush()
3069 
 
3070 
  def recv_getSimilarItemsCatalogIds(self, ):
3071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3072 
    if mtype == TMessageType.EXCEPTION:
3073 
      x = TApplicationException()
3074 
      x.read(self._iprot)
3075 
      self._iprot.readMessageEnd()
3076 
      raise x
3077 
    result = getSimilarItemsCatalogIds_result()
3078 
    result.read(self._iprot)
3079 
    self._iprot.readMessageEnd()
3080 
    if result.success is not None:
3081 
      return result.success
3082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3083 
 
3084 
  def addProductNotification(self, itemId, email):
3085 
    """
3086 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3087 
 
3088 
    Parameters:
3089 
     - itemId
3090 
     - email
3091 
    """
3092 
    self.send_addProductNotification(itemId, email)
3093 
    return self.recv_addProductNotification()
3094 
 
3095 
  def send_addProductNotification(self, itemId, email):
3096 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3097 
    args = addProductNotification_args()
3098 
    args.itemId = itemId
3099 
    args.email = email
3100 
    args.write(self._oprot)
3101 
    self._oprot.writeMessageEnd()
3102 
    self._oprot.trans.flush()
3103 
 
3104 
  def recv_addProductNotification(self, ):
3105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3106 
    if mtype == TMessageType.EXCEPTION:
3107 
      x = TApplicationException()
3108 
      x.read(self._iprot)
3109 
      self._iprot.readMessageEnd()
3110 
      raise x
3111 
    result = addProductNotification_result()
3112 
    result.read(self._iprot)
3113 
    self._iprot.readMessageEnd()
3114 
    if result.success is not None:
3115 
      return result.success
3116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3117 
 
3118 
  def sendProductNotifications(self, ):
3119 
    """
3120 
    Send the product notifications to the users for items which has stock.
3121 
    """
3122 
    self.send_sendProductNotifications()
3123 
    return self.recv_sendProductNotifications()
3124 
 
3125 
  def send_sendProductNotifications(self, ):
3126 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3127 
    args = sendProductNotifications_args()
3128 
    args.write(self._oprot)
3129 
    self._oprot.writeMessageEnd()
3130 
    self._oprot.trans.flush()
3131 
 
3132 
  def recv_sendProductNotifications(self, ):
3133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3134 
    if mtype == TMessageType.EXCEPTION:
3135 
      x = TApplicationException()
3136 
      x.read(self._iprot)
3137 
      self._iprot.readMessageEnd()
3138 
      raise x
3139 
    result = sendProductNotifications_result()
3140 
    result.read(self._iprot)
3141 
    self._iprot.readMessageEnd()
3142 
    if result.success is not None:
3143 
      return result.success
3144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3145 
 
3146 
  def getAllBrandsByCategory(self, categoryId):
3147 
    """
3148 
    Returns list of brand names for a given category Id
3149 
 
3150 
    Parameters:
3151 
     - categoryId
3152 
    """
3153 
    self.send_getAllBrandsByCategory(categoryId)
3154 
    return self.recv_getAllBrandsByCategory()
3155 
 
3156 
  def send_getAllBrandsByCategory(self, categoryId):
3157 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3158 
    args = getAllBrandsByCategory_args()
3159 
    args.categoryId = categoryId
3160 
    args.write(self._oprot)
3161 
    self._oprot.writeMessageEnd()
3162 
    self._oprot.trans.flush()
3163 
 
3164 
  def recv_getAllBrandsByCategory(self, ):
3165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3166 
    if mtype == TMessageType.EXCEPTION:
3167 
      x = TApplicationException()
3168 
      x.read(self._iprot)
3169 
      self._iprot.readMessageEnd()
3170 
      raise x
3171 
    result = getAllBrandsByCategory_result()
3172 
    result.read(self._iprot)
3173 
    self._iprot.readMessageEnd()
3174 
    if result.success is not None:
3175 
      return result.success
3176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3177 
 
3178 
  def getAllBrands(self, ):
3179 
    """
3180 
    Returns list of brand names
3181 
    """
3182 
    self.send_getAllBrands()
3183 
    return self.recv_getAllBrands()
3184 
 
3185 
  def send_getAllBrands(self, ):
3186 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3187 
    args = getAllBrands_args()
3188 
    args.write(self._oprot)
3189 
    self._oprot.writeMessageEnd()
3190 
    self._oprot.trans.flush()
3191 
 
3192 
  def recv_getAllBrands(self, ):
3193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3194 
    if mtype == TMessageType.EXCEPTION:
3195 
      x = TApplicationException()
3196 
      x.read(self._iprot)
3197 
      self._iprot.readMessageEnd()
3198 
      raise x
3199 
    result = getAllBrands_result()
3200 
    result.read(self._iprot)
3201 
    self._iprot.readMessageEnd()
3202 
    if result.success is not None:
3203 
      return result.success
3204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3205 
 
3206 
  def getAllSources(self, ):
3207 
    """
3208 
    Return list of all sources
3209 
    """
3210 
    self.send_getAllSources()
3211 
    return self.recv_getAllSources()
3212 
 
3213 
  def send_getAllSources(self, ):
3214 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3215 
    args = getAllSources_args()
3216 
    args.write(self._oprot)
3217 
    self._oprot.writeMessageEnd()
3218 
    self._oprot.trans.flush()
3219 
 
3220 
  def recv_getAllSources(self, ):
3221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3222 
    if mtype == TMessageType.EXCEPTION:
3223 
      x = TApplicationException()
3224 
      x.read(self._iprot)
3225 
      self._iprot.readMessageEnd()
3226 
      raise x
3227 
    result = getAllSources_result()
3228 
    result.read(self._iprot)
3229 
    self._iprot.readMessageEnd()
3230 
    if result.success is not None:
3231 
      return result.success
3232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3233 
 
3234 
  def getItemPricingBySource(self, itemId, sourceId):
3235 
    """
3236 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3237 
 
3238 
    Parameters:
3239 
     - itemId
3240 
     - sourceId
3241 
    """
3242 
    self.send_getItemPricingBySource(itemId, sourceId)
3243 
    return self.recv_getItemPricingBySource()
3244 
 
3245 
  def send_getItemPricingBySource(self, itemId, sourceId):
3246 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3247 
    args = getItemPricingBySource_args()
3248 
    args.itemId = itemId
3249 
    args.sourceId = sourceId
3250 
    args.write(self._oprot)
3251 
    self._oprot.writeMessageEnd()
3252 
    self._oprot.trans.flush()
3253 
 
3254 
  def recv_getItemPricingBySource(self, ):
3255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3256 
    if mtype == TMessageType.EXCEPTION:
3257 
      x = TApplicationException()
3258 
      x.read(self._iprot)
3259 
      self._iprot.readMessageEnd()
3260 
      raise x
3261 
    result = getItemPricingBySource_result()
3262 
    result.read(self._iprot)
3263 
    self._iprot.readMessageEnd()
3264 
    if result.success is not None:
3265 
      return result.success
3266 
    if result.cex is not None:
3267 
      raise result.cex
3268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3269 
 
3270 
  def addSourceItemPricing(self, sourceItemPricing):
3271 
    """
3272 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3273 
    If item is not found or source is not found, it will throw exception.
3274 
 
3275 
    Parameters:
3276 
     - sourceItemPricing
3277 
    """
3278 
    self.send_addSourceItemPricing(sourceItemPricing)
3279 
    self.recv_addSourceItemPricing()
3280 
 
3281 
  def send_addSourceItemPricing(self, sourceItemPricing):
3282 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3283 
    args = addSourceItemPricing_args()
3284 
    args.sourceItemPricing = sourceItemPricing
3285 
    args.write(self._oprot)
3286 
    self._oprot.writeMessageEnd()
3287 
    self._oprot.trans.flush()
3288 
 
3289 
  def recv_addSourceItemPricing(self, ):
3290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3291 
    if mtype == TMessageType.EXCEPTION:
3292 
      x = TApplicationException()
3293 
      x.read(self._iprot)
3294 
      self._iprot.readMessageEnd()
3295 
      raise x
3296 
    result = addSourceItemPricing_result()
3297 
    result.read(self._iprot)
3298 
    self._iprot.readMessageEnd()
3299 
    if result.cex is not None:
3300 
      raise result.cex
3301 
    return
3302 
 
3303 
  def getAllSourcePricing(self, itemId):
3304 
    """
3305 
    Returns the list of source pricing information of an item.
3306 
    Raises an exception if item not found corresponding to itemId
3307 
 
3308 
    Parameters:
3309 
     - itemId
3310 
    """
3311 
    self.send_getAllSourcePricing(itemId)
3312 
    return self.recv_getAllSourcePricing()
3313 
 
3314 
  def send_getAllSourcePricing(self, itemId):
3315 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3316 
    args = getAllSourcePricing_args()
3317 
    args.itemId = itemId
3318 
    args.write(self._oprot)
3319 
    self._oprot.writeMessageEnd()
3320 
    self._oprot.trans.flush()
3321 
 
3322 
  def recv_getAllSourcePricing(self, ):
3323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3324 
    if mtype == TMessageType.EXCEPTION:
3325 
      x = TApplicationException()
3326 
      x.read(self._iprot)
3327 
      self._iprot.readMessageEnd()
3328 
      raise x
3329 
    result = getAllSourcePricing_result()
3330 
    result.read(self._iprot)
3331 
    self._iprot.readMessageEnd()
3332 
    if result.success is not None:
3333 
      return result.success
3334 
    if result.cex is not None:
3335 
      raise result.cex
3336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3337 
 
3338 
  def getItemForSource(self, item_id, sourceId):
3339 
    """
3340 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3341 
 
3342 
    Parameters:
3343 
     - item_id
3344 
     - sourceId
3345 
    """
3346 
    self.send_getItemForSource(item_id, sourceId)
3347 
    return self.recv_getItemForSource()
3348 
 
3349 
  def send_getItemForSource(self, item_id, sourceId):
3350 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3351 
    args = getItemForSource_args()
3352 
    args.item_id = item_id
3353 
    args.sourceId = sourceId
3354 
    args.write(self._oprot)
3355 
    self._oprot.writeMessageEnd()
3356 
    self._oprot.trans.flush()
3357 
 
3358 
  def recv_getItemForSource(self, ):
3359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3360 
    if mtype == TMessageType.EXCEPTION:
3361 
      x = TApplicationException()
3362 
      x.read(self._iprot)
3363 
      self._iprot.readMessageEnd()
3364 
      raise x
3365 
    result = getItemForSource_result()
3366 
    result.read(self._iprot)
3367 
    self._iprot.readMessageEnd()
3368 
    if result.success is not None:
3369 
      return result.success
3370 
    if result.cex is not None:
3371 
      raise result.cex
3372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3373 
 
3374 
  def searchItemsInRange(self, searchTerms, offset, limit):
3375 
    """
3376 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3377 
 
3378 
    Parameters:
3379 
     - searchTerms
3380 
     - offset
3381 
     - limit
3382 
    """
3383 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3384 
    return self.recv_searchItemsInRange()
3385 
 
3386 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3387 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3388 
    args = searchItemsInRange_args()
3389 
    args.searchTerms = searchTerms
3390 
    args.offset = offset
3391 
    args.limit = limit
3392 
    args.write(self._oprot)
3393 
    self._oprot.writeMessageEnd()
3394 
    self._oprot.trans.flush()
3395 
 
3396 
  def recv_searchItemsInRange(self, ):
3397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3398 
    if mtype == TMessageType.EXCEPTION:
3399 
      x = TApplicationException()
3400 
      x.read(self._iprot)
3401 
      self._iprot.readMessageEnd()
3402 
      raise x
3403 
    result = searchItemsInRange_result()
3404 
    result.read(self._iprot)
3405 
    self._iprot.readMessageEnd()
3406 
    if result.success is not None:
3407 
      return result.success
3408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3409 
 
3410 
  def getSearchResultCount(self, searchTerms):
3411 
    """
3412 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3413 
 
3414 
    Parameters:
3415 
     - searchTerms
3416 
    """
3417 
    self.send_getSearchResultCount(searchTerms)
3418 
    return self.recv_getSearchResultCount()
3419 
 
3420 
  def send_getSearchResultCount(self, searchTerms):
3421 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3422 
    args = getSearchResultCount_args()
3423 
    args.searchTerms = searchTerms
3424 
    args.write(self._oprot)
3425 
    self._oprot.writeMessageEnd()
3426 
    self._oprot.trans.flush()
3427 
 
3428 
  def recv_getSearchResultCount(self, ):
3429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3430 
    if mtype == TMessageType.EXCEPTION:
3431 
      x = TApplicationException()
3432 
      x.read(self._iprot)
3433 
      self._iprot.readMessageEnd()
3434 
      raise x
3435 
    result = getSearchResultCount_result()
3436 
    result.read(self._iprot)
3437 
    self._iprot.readMessageEnd()
3438 
    if result.success is not None:
3439 
      return result.success
3440 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3441 
 
3442 
  def getProductNotifications(self, startDateTime):
3443 
    """
3444 
    Returns a list of product notifications added after a supplied datetime
3445 
 
3446 
    Parameters:
3447 
     - startDateTime
3448 
    """
3449 
    self.send_getProductNotifications(startDateTime)
3450 
    return self.recv_getProductNotifications()
3451 
 
3452 
  def send_getProductNotifications(self, startDateTime):
3453 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3454 
    args = getProductNotifications_args()
3455 
    args.startDateTime = startDateTime
3456 
    args.write(self._oprot)
3457 
    self._oprot.writeMessageEnd()
3458 
    self._oprot.trans.flush()
3459 
 
3460 
  def recv_getProductNotifications(self, ):
3461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3462 
    if mtype == TMessageType.EXCEPTION:
3463 
      x = TApplicationException()
3464 
      x.read(self._iprot)
3465 
      self._iprot.readMessageEnd()
3466 
      raise x
3467 
    result = getProductNotifications_result()
3468 
    result.read(self._iprot)
3469 
    self._iprot.readMessageEnd()
3470 
    if result.success is not None:
3471 
      return result.success
3472 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3473 
 
7897 amar.kumar 3474 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3475 
    """
3476 
    Returns a list of count of requests for product notification against each item
3477 
 
3478 
    Parameters:
3479 
     - startDateTime
7897 amar.kumar 3480 
     - categoryId
5944 mandeep.dh 3481 
    """
7897 amar.kumar 3482 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3483 
    return self.recv_getProductNotificationRequestCount()
3484 
 
7897 amar.kumar 3485 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3486 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3487 
    args = getProductNotificationRequestCount_args()
3488 
    args.startDateTime = startDateTime
7897 amar.kumar 3489 
    args.categoryId = categoryId
5944 mandeep.dh 3490 
    args.write(self._oprot)
3491 
    self._oprot.writeMessageEnd()
3492 
    self._oprot.trans.flush()
3493 
 
3494 
  def recv_getProductNotificationRequestCount(self, ):
3495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3496 
    if mtype == TMessageType.EXCEPTION:
3497 
      x = TApplicationException()
3498 
      x.read(self._iprot)
3499 
      self._iprot.readMessageEnd()
3500 
      raise x
3501 
    result = getProductNotificationRequestCount_result()
3502 
    result.read(self._iprot)
3503 
    self._iprot.readMessageEnd()
3504 
    if result.success is not None:
3505 
      return result.success
3506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3507 
 
3508 
  def addAuthorizationLog(self, itemId, username, reason):
3509 
    """
3510 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3511 
 
3512 
    Parameters:
3513 
     - itemId
3514 
     - username
3515 
     - reason
3516 
    """
3517 
    self.send_addAuthorizationLog(itemId, username, reason)
3518 
    return self.recv_addAuthorizationLog()
3519 
 
3520 
  def send_addAuthorizationLog(self, itemId, username, reason):
3521 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3522 
    args = addAuthorizationLog_args()
3523 
    args.itemId = itemId
3524 
    args.username = username
3525 
    args.reason = reason
3526 
    args.write(self._oprot)
3527 
    self._oprot.writeMessageEnd()
3528 
    self._oprot.trans.flush()
3529 
 
3530 
  def recv_addAuthorizationLog(self, ):
3531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3532 
    if mtype == TMessageType.EXCEPTION:
3533 
      x = TApplicationException()
3534 
      x.read(self._iprot)
3535 
      self._iprot.readMessageEnd()
3536 
      raise x
3537 
    result = addAuthorizationLog_result()
3538 
    result.read(self._iprot)
3539 
    self._iprot.readMessageEnd()
3540 
    if result.success is not None:
3541 
      return result.success
3542 
    if result.cex is not None:
3543 
      raise result.cex
3544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3545 
 
3546 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3547 
    """
3548 
    Parameters:
3549 
     - catalog_item_id
3550 
     - voucherType
3551 
     - voucherAmount
3552 
    """
3553 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3554 
    return self.recv_addupdateVoucherForItem()
3555 
 
3556 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3557 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3558 
    args = addupdateVoucherForItem_args()
3559 
    args.catalog_item_id = catalog_item_id
3560 
    args.voucherType = voucherType
3561 
    args.voucherAmount = voucherAmount
3562 
    args.write(self._oprot)
3563 
    self._oprot.writeMessageEnd()
3564 
    self._oprot.trans.flush()
3565 
 
3566 
  def recv_addupdateVoucherForItem(self, ):
3567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3568 
    if mtype == TMessageType.EXCEPTION:
3569 
      x = TApplicationException()
3570 
      x.read(self._iprot)
3571 
      self._iprot.readMessageEnd()
3572 
      raise x
3573 
    result = addupdateVoucherForItem_result()
3574 
    result.read(self._iprot)
3575 
    self._iprot.readMessageEnd()
3576 
    if result.success is not None:
3577 
      return result.success
3578 
    if result.cex is not None:
3579 
      raise result.cex
3580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3581 
 
3582 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3583 
    """
3584 
    Parameters:
3585 
     - catalog_item_id
3586 
     - voucherType
3587 
    """
3588 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3589 
    return self.recv_deleteVoucherForItem()
3590 
 
3591 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3592 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3593 
    args = deleteVoucherForItem_args()
3594 
    args.catalog_item_id = catalog_item_id
3595 
    args.voucherType = voucherType
3596 
    args.write(self._oprot)
3597 
    self._oprot.writeMessageEnd()
3598 
    self._oprot.trans.flush()
3599 
 
3600 
  def recv_deleteVoucherForItem(self, ):
3601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3602 
    if mtype == TMessageType.EXCEPTION:
3603 
      x = TApplicationException()
3604 
      x.read(self._iprot)
3605 
      self._iprot.readMessageEnd()
3606 
      raise x
3607 
    result = deleteVoucherForItem_result()
3608 
    result.read(self._iprot)
3609 
    self._iprot.readMessageEnd()
3610 
    if result.success is not None:
3611 
      return result.success
3612 
    if result.cex is not None:
3613 
      raise result.cex
3614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3615 
 
3616 
  def getVoucherAmount(self, itemId, voucherType):
3617 
    """
3618 
    Parameters:
3619 
     - itemId
3620 
     - voucherType
3621 
    """
3622 
    self.send_getVoucherAmount(itemId, voucherType)
3623 
    return self.recv_getVoucherAmount()
3624 
 
3625 
  def send_getVoucherAmount(self, itemId, voucherType):
3626 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3627 
    args = getVoucherAmount_args()
3628 
    args.itemId = itemId
3629 
    args.voucherType = voucherType
3630 
    args.write(self._oprot)
3631 
    self._oprot.writeMessageEnd()
3632 
    self._oprot.trans.flush()
3633 
 
3634 
  def recv_getVoucherAmount(self, ):
3635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3636 
    if mtype == TMessageType.EXCEPTION:
3637 
      x = TApplicationException()
3638 
      x.read(self._iprot)
3639 
      self._iprot.readMessageEnd()
3640 
      raise x
3641 
    result = getVoucherAmount_result()
3642 
    result.read(self._iprot)
3643 
    self._iprot.readMessageEnd()
3644 
    if result.success is not None:
3645 
      return result.success
3646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3647 
 
3648 
  def getAllItemVouchers(self, itemId):
3649 
    """
3650 
    Parameters:
3651 
     - itemId
3652 
    """
3653 
    self.send_getAllItemVouchers(itemId)
3654 
    return self.recv_getAllItemVouchers()
3655 
 
3656 
  def send_getAllItemVouchers(self, itemId):
3657 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3658 
    args = getAllItemVouchers_args()
3659 
    args.itemId = itemId
3660 
    args.write(self._oprot)
3661 
    self._oprot.writeMessageEnd()
3662 
    self._oprot.trans.flush()
3663 
 
3664 
  def recv_getAllItemVouchers(self, ):
3665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3666 
    if mtype == TMessageType.EXCEPTION:
3667 
      x = TApplicationException()
3668 
      x.read(self._iprot)
3669 
      self._iprot.readMessageEnd()
3670 
      raise x
3671 
    result = getAllItemVouchers_result()
3672 
    result.read(self._iprot)
3673 
    self._iprot.readMessageEnd()
3674 
    if result.success is not None:
3675 
      return result.success
3676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3677 
 
3678 
  def isValidCatalogItemId(self, catalog_item_id):
3679 
    """
3680 
    Parameters:
3681 
     - catalog_item_id
3682 
    """
3683 
    self.send_isValidCatalogItemId(catalog_item_id)
3684 
    return self.recv_isValidCatalogItemId()
3685 
 
3686 
  def send_isValidCatalogItemId(self, catalog_item_id):
3687 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3688 
    args = isValidCatalogItemId_args()
3689 
    args.catalog_item_id = catalog_item_id
3690 
    args.write(self._oprot)
3691 
    self._oprot.writeMessageEnd()
3692 
    self._oprot.trans.flush()
3693 
 
3694 
  def recv_isValidCatalogItemId(self, ):
3695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3696 
    if mtype == TMessageType.EXCEPTION:
3697 
      x = TApplicationException()
3698 
      x.read(self._iprot)
3699 
      self._iprot.readMessageEnd()
3700 
      raise x
3701 
    result = isValidCatalogItemId_result()
3702 
    result.read(self._iprot)
3703 
    self._iprot.readMessageEnd()
3704 
    if result.success is not None:
3705 
      return result.success
3706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3707 
 
7330 amit.gupta 3708 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3709 
    """
3710 
    Parameters:
3711 
     - itemId
7330 amit.gupta 3712 
     - stateId
6039 amit.gupta 3713 
     - price
3714 
    """
7330 amit.gupta 3715 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3716 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3717 
 
7330 amit.gupta 3718 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3719 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3720 
    args = getVatPercentageForItem_args()
3721 
    args.itemId = itemId
7330 amit.gupta 3722 
    args.stateId = stateId
6039 amit.gupta 3723 
    args.price = price
3724 
    args.write(self._oprot)
3725 
    self._oprot.writeMessageEnd()
3726 
    self._oprot.trans.flush()
3727 
 
3728 
  def recv_getVatPercentageForItem(self, ):
3729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3730 
    if mtype == TMessageType.EXCEPTION:
3731 
      x = TApplicationException()
3732 
      x.read(self._iprot)
3733 
      self._iprot.readMessageEnd()
3734 
      raise x
3735 
    result = getVatPercentageForItem_result()
3736 
    result.read(self._iprot)
3737 
    self._iprot.readMessageEnd()
3738 
    if result.success is not None:
3739 
      return result.success
7340 amit.gupta 3740 
    if result.cex is not None:
3741 
      raise result.cex
6039 amit.gupta 3742 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3743 
 
3744 
  def getVatAmountForItem(self, itemId, price):
3745 
    """
3746 
    Parameters:
3747 
     - itemId
3748 
     - price
3749 
    """
3750 
    self.send_getVatAmountForItem(itemId, price)
3751 
    return self.recv_getVatAmountForItem()
3752 
 
3753 
  def send_getVatAmountForItem(self, itemId, price):
3754 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3755 
    args = getVatAmountForItem_args()
3756 
    args.itemId = itemId
3757 
    args.price = price
3758 
    args.write(self._oprot)
3759 
    self._oprot.writeMessageEnd()
3760 
    self._oprot.trans.flush()
3761 
 
3762 
  def recv_getVatAmountForItem(self, ):
3763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3764 
    if mtype == TMessageType.EXCEPTION:
3765 
      x = TApplicationException()
3766 
      x.read(self._iprot)
3767 
      self._iprot.readMessageEnd()
3768 
      raise x
3769 
    result = getVatAmountForItem_result()
3770 
    result.read(self._iprot)
3771 
    self._iprot.readMessageEnd()
3772 
    if result.success is not None:
3773 
      return result.success
3774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3775 
 
6531 vikram.rag 3776 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3777 
    """
3778 
    Parameters:
3779 
     - offset
3780 
     - limit
3781 
    """
3782 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3783 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3784 
 
6531 vikram.rag 3785 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3786 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3787 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3788 
    args.offset = offset
3789 
    args.limit = limit
3790 
    args.write(self._oprot)
3791 
    self._oprot.writeMessageEnd()
3792 
    self._oprot.trans.flush()
3793 
 
3794 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3796 
    if mtype == TMessageType.EXCEPTION:
3797 
      x = TApplicationException()
3798 
      x.read(self._iprot)
3799 
      self._iprot.readMessageEnd()
3800 
      raise x
3801 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3802 
    result.read(self._iprot)
3803 
    self._iprot.readMessageEnd()
3804 
    if result.success is not None:
3805 
      return result.success
3806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3807 
 
6821 amar.kumar 3808 
  def getAllAliveItems(self, ):
3809 
    self.send_getAllAliveItems()
3810 
    return self.recv_getAllAliveItems()
3811 
 
3812 
  def send_getAllAliveItems(self, ):
3813 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3814 
    args = getAllAliveItems_args()
3815 
    args.write(self._oprot)
3816 
    self._oprot.writeMessageEnd()
3817 
    self._oprot.trans.flush()
3818 
 
3819 
  def recv_getAllAliveItems(self, ):
3820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3821 
    if mtype == TMessageType.EXCEPTION:
3822 
      x = TApplicationException()
3823 
      x.read(self._iprot)
3824 
      self._iprot.readMessageEnd()
3825 
      raise x
3826 
    result = getAllAliveItems_result()
3827 
    result.read(self._iprot)
3828 
    self._iprot.readMessageEnd()
3829 
    if result.success is not None:
3830 
      return result.success
3831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3832 
 
6921 anupam.sin 3833 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3834 
    """
3835 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3836 
 
6805 anupam.sin 3837 
    Parameters:
3838 
     - itemId
6921 anupam.sin 3839 
     - price
6805 anupam.sin 3840 
     - insurerId
3841 
     - quantity
3842 
    """
6921 anupam.sin 3843 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3844 
    return self.recv_getInsuranceAmount()
3845 
 
6921 anupam.sin 3846 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3847 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3848 
    args = getInsuranceAmount_args()
3849 
    args.itemId = itemId
6921 anupam.sin 3850 
    args.price = price
6805 anupam.sin 3851 
    args.insurerId = insurerId
3852 
    args.quantity = quantity
3853 
    args.write(self._oprot)
3854 
    self._oprot.writeMessageEnd()
3855 
    self._oprot.trans.flush()
3856 
 
3857 
  def recv_getInsuranceAmount(self, ):
3858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3859 
    if mtype == TMessageType.EXCEPTION:
3860 
      x = TApplicationException()
3861 
      x.read(self._iprot)
3862 
      self._iprot.readMessageEnd()
3863 
      raise x
3864 
    result = getInsuranceAmount_result()
3865 
    result.read(self._iprot)
3866 
    self._iprot.readMessageEnd()
3867 
    if result.success is not None:
3868 
      return result.success
3869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3870 
 
3871 
  def getInsurer(self, insurerId):
3872 
    """
3873 
    Parameters:
3874 
     - insurerId
3875 
    """
3876 
    self.send_getInsurer(insurerId)
3877 
    return self.recv_getInsurer()
3878 
 
3879 
  def send_getInsurer(self, insurerId):
3880 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3881 
    args = getInsurer_args()
3882 
    args.insurerId = insurerId
3883 
    args.write(self._oprot)
3884 
    self._oprot.writeMessageEnd()
3885 
    self._oprot.trans.flush()
3886 
 
3887 
  def recv_getInsurer(self, ):
3888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3889 
    if mtype == TMessageType.EXCEPTION:
3890 
      x = TApplicationException()
3891 
      x.read(self._iprot)
3892 
      self._iprot.readMessageEnd()
3893 
      raise x
3894 
    result = getInsurer_result()
3895 
    result.read(self._iprot)
3896 
    self._iprot.readMessageEnd()
3897 
    if result.success is not None:
3898 
      return result.success
3899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3900 
 
6838 vikram.rag 3901 
  def getAllInsurers(self, ):
3902 
    self.send_getAllInsurers()
3903 
    return self.recv_getAllInsurers()
6805 anupam.sin 3904 
 
6838 vikram.rag 3905 
  def send_getAllInsurers(self, ):
3906 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3907 
    args = getAllInsurers_args()
3908 
    args.write(self._oprot)
3909 
    self._oprot.writeMessageEnd()
3910 
    self._oprot.trans.flush()
3911 
 
3912 
  def recv_getAllInsurers(self, ):
3913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3914 
    if mtype == TMessageType.EXCEPTION:
3915 
      x = TApplicationException()
3916 
      x.read(self._iprot)
3917 
      self._iprot.readMessageEnd()
3918 
      raise x
3919 
    result = getAllInsurers_result()
3920 
    result.read(self._iprot)
3921 
    self._iprot.readMessageEnd()
3922 
    if result.success is not None:
3923 
      return result.success
3924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3925 
 
6962 rajveer 3926 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3927 
    """
3928 
    Parameters:
3929 
     - insurerId
3930 
     - amount
3931 
    """
3932 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3933 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3934 
 
6962 rajveer 3935 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3936 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3937 
    args = updateInsuranceDeclaredAmount_args()
3938 
    args.insurerId = insurerId
3939 
    args.amount = amount
3940 
    args.write(self._oprot)
3941 
    self._oprot.writeMessageEnd()
3942 
    self._oprot.trans.flush()
3943 
 
3944 
  def recv_updateInsuranceDeclaredAmount(self, ):
3945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3946 
    if mtype == TMessageType.EXCEPTION:
3947 
      x = TApplicationException()
3948 
      x.read(self._iprot)
3949 
      self._iprot.readMessageEnd()
3950 
      raise x
3951 
    result = updateInsuranceDeclaredAmount_result()
3952 
    result.read(self._iprot)
3953 
    self._iprot.readMessageEnd()
3954 
    return
3955 
 
7190 amar.kumar 3956 
  def getFreebieForItem(self, itemId):
3957 
    """
3958 
    Parameters:
3959 
     - itemId
3960 
    """
3961 
    self.send_getFreebieForItem(itemId)
3962 
    return self.recv_getFreebieForItem()
6962 rajveer 3963 
 
7190 amar.kumar 3964 
  def send_getFreebieForItem(self, itemId):
3965 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3966 
    args = getFreebieForItem_args()
3967 
    args.itemId = itemId
3968 
    args.write(self._oprot)
3969 
    self._oprot.writeMessageEnd()
3970 
    self._oprot.trans.flush()
3971 
 
3972 
  def recv_getFreebieForItem(self, ):
3973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3974 
    if mtype == TMessageType.EXCEPTION:
3975 
      x = TApplicationException()
3976 
      x.read(self._iprot)
3977 
      self._iprot.readMessageEnd()
3978 
      raise x
3979 
    result = getFreebieForItem_result()
3980 
    result.read(self._iprot)
3981 
    self._iprot.readMessageEnd()
3982 
    if result.success is not None:
3983 
      return result.success
3984 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3985 
 
3986 
  def addOrUpdateFreebieForItem(self, freebieItem):
3987 
    """
3988 
    Parameters:
3989 
     - freebieItem
3990 
    """
3991 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3992 
    self.recv_addOrUpdateFreebieForItem()
3993 
 
3994 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3995 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3996 
    args = addOrUpdateFreebieForItem_args()
3997 
    args.freebieItem = freebieItem
3998 
    args.write(self._oprot)
3999 
    self._oprot.writeMessageEnd()
4000 
    self._oprot.trans.flush()
4001 
 
4002 
  def recv_addOrUpdateFreebieForItem(self, ):
4003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4004 
    if mtype == TMessageType.EXCEPTION:
4005 
      x = TApplicationException()
4006 
      x.read(self._iprot)
4007 
      self._iprot.readMessageEnd()
4008 
      raise x
4009 
    result = addOrUpdateFreebieForItem_result()
4010 
    result.read(self._iprot)
4011 
    self._iprot.readMessageEnd()
4012 
    return
4013 
 
7272 amit.gupta 4014 
  def addOrUpdateBrandInfo(self, brandInfo):
4015 
    """
4016 
    Parameters:
4017 
     - brandInfo
4018 
    """
4019 
    self.send_addOrUpdateBrandInfo(brandInfo)
4020 
    self.recv_addOrUpdateBrandInfo()
4021 
 
4022 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4023 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4024 
    args = addOrUpdateBrandInfo_args()
4025 
    args.brandInfo = brandInfo
4026 
    args.write(self._oprot)
4027 
    self._oprot.writeMessageEnd()
4028 
    self._oprot.trans.flush()
4029 
 
4030 
  def recv_addOrUpdateBrandInfo(self, ):
4031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4032 
    if mtype == TMessageType.EXCEPTION:
4033 
      x = TApplicationException()
4034 
      x.read(self._iprot)
4035 
      self._iprot.readMessageEnd()
4036 
      raise x
4037 
    result = addOrUpdateBrandInfo_result()
4038 
    result.read(self._iprot)
4039 
    self._iprot.readMessageEnd()
4040 
    return
4041 
 
4042 
  def getBrandInfo(self, ):
4043 
    self.send_getBrandInfo()
4044 
    return self.recv_getBrandInfo()
4045 
 
4046 
  def send_getBrandInfo(self, ):
4047 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4048 
    args = getBrandInfo_args()
4049 
    args.write(self._oprot)
4050 
    self._oprot.writeMessageEnd()
4051 
    self._oprot.trans.flush()
4052 
 
4053 
  def recv_getBrandInfo(self, ):
4054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4055 
    if mtype == TMessageType.EXCEPTION:
4056 
      x = TApplicationException()
4057 
      x.read(self._iprot)
4058 
      self._iprot.readMessageEnd()
4059 
      raise x
4060 
    result = getBrandInfo_result()
4061 
    result.read(self._iprot)
4062 
    self._iprot.readMessageEnd()
4063 
    if result.success is not None:
4064 
      return result.success
4065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4066 
 
7256 rajveer 4067 
  def getStorePricing(self, itemId):
4068 
    """
4069 
    Parameters:
4070 
     - itemId
4071 
    """
4072 
    self.send_getStorePricing(itemId)
4073 
    return self.recv_getStorePricing()
7190 amar.kumar 4074 
 
7256 rajveer 4075 
  def send_getStorePricing(self, itemId):
4076 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4077 
    args = getStorePricing_args()
4078 
    args.itemId = itemId
4079 
    args.write(self._oprot)
4080 
    self._oprot.writeMessageEnd()
4081 
    self._oprot.trans.flush()
4082 
 
4083 
  def recv_getStorePricing(self, ):
4084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4085 
    if mtype == TMessageType.EXCEPTION:
4086 
      x = TApplicationException()
4087 
      x.read(self._iprot)
4088 
      self._iprot.readMessageEnd()
4089 
      raise x
4090 
    result = getStorePricing_result()
4091 
    result.read(self._iprot)
4092 
    self._iprot.readMessageEnd()
4093 
    if result.success is not None:
4094 
      return result.success
4095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4096 
 
7306 rajveer 4097 
  def getStorePricings(self, itemIds):
4098 
    """
4099 
    Parameters:
4100 
     - itemIds
4101 
    """
4102 
    self.send_getStorePricings(itemIds)
4103 
    return self.recv_getStorePricings()
4104 
 
4105 
  def send_getStorePricings(self, itemIds):
4106 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4107 
    args = getStorePricings_args()
4108 
    args.itemIds = itemIds
4109 
    args.write(self._oprot)
4110 
    self._oprot.writeMessageEnd()
4111 
    self._oprot.trans.flush()
4112 
 
4113 
  def recv_getStorePricings(self, ):
4114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4115 
    if mtype == TMessageType.EXCEPTION:
4116 
      x = TApplicationException()
4117 
      x.read(self._iprot)
4118 
      self._iprot.readMessageEnd()
4119 
      raise x
4120 
    result = getStorePricings_result()
4121 
    result.read(self._iprot)
4122 
    self._iprot.readMessageEnd()
4123 
    if result.success is not None:
4124 
      return result.success
4125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4126 
 
7382 rajveer 4127 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4128 
    """
4129 
    Parameters:
4130 
     - sp
7382 rajveer 4131 
     - allColors
7265 rajveer 4132 
    """
7382 rajveer 4133 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4134 
    self.recv_updateStorePricing()
7256 rajveer 4135 
 
7382 rajveer 4136 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4137 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4138 
    args = updateStorePricing_args()
4139 
    args.sp = sp
7382 rajveer 4140 
    args.allColors = allColors
7265 rajveer 4141 
    args.write(self._oprot)
4142 
    self._oprot.writeMessageEnd()
4143 
    self._oprot.trans.flush()
4144 
 
4145 
  def recv_updateStorePricing(self, ):
4146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4147 
    if mtype == TMessageType.EXCEPTION:
4148 
      x = TApplicationException()
4149 
      x.read(self._iprot)
4150 
      self._iprot.readMessageEnd()
4151 
      raise x
4152 
    result = updateStorePricing_result()
4153 
    result.read(self._iprot)
4154 
    self._iprot.readMessageEnd()
4155 
    return
4156 
 
7281 kshitij.so 4157 
  def getAllAmazonListedItems(self, ):
4158 
    self.send_getAllAmazonListedItems()
4159 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4160 
 
7281 kshitij.so 4161 
  def send_getAllAmazonListedItems(self, ):
4162 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4163 
    args = getAllAmazonListedItems_args()
4164 
    args.write(self._oprot)
4165 
    self._oprot.writeMessageEnd()
4166 
    self._oprot.trans.flush()
4167 
 
4168 
  def recv_getAllAmazonListedItems(self, ):
4169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4170 
    if mtype == TMessageType.EXCEPTION:
4171 
      x = TApplicationException()
4172 
      x.read(self._iprot)
4173 
      self._iprot.readMessageEnd()
4174 
      raise x
4175 
    result = getAllAmazonListedItems_result()
4176 
    result.read(self._iprot)
4177 
    self._iprot.readMessageEnd()
4178 
    if result.success is not None:
4179 
      return result.success
4180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4181 
 
8619 kshitij.so 4182 
  def searchAmazonItems(self, searchTerm, offset, limit):
4183 
    """
4184 
    Parameters:
4185 
     - searchTerm
4186 
     - offset
4187 
     - limit
4188 
    """
4189 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4190 
    return self.recv_searchAmazonItems()
4191 
 
4192 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4193 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4194 
    args = searchAmazonItems_args()
4195 
    args.searchTerm = searchTerm
4196 
    args.offset = offset
4197 
    args.limit = limit
4198 
    args.write(self._oprot)
4199 
    self._oprot.writeMessageEnd()
4200 
    self._oprot.trans.flush()
4201 
 
4202 
  def recv_searchAmazonItems(self, ):
4203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4204 
    if mtype == TMessageType.EXCEPTION:
4205 
      x = TApplicationException()
4206 
      x.read(self._iprot)
4207 
      self._iprot.readMessageEnd()
4208 
      raise x
4209 
    result = searchAmazonItems_result()
4210 
    result.read(self._iprot)
4211 
    self._iprot.readMessageEnd()
4212 
    if result.success is not None:
4213 
      return result.success
4214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4215 
 
4216 
  def getAmazonSearchResultCount(self, searchTerm):
4217 
    """
4218 
    Parameters:
4219 
     - searchTerm
4220 
    """
4221 
    self.send_getAmazonSearchResultCount(searchTerm)
4222 
    return self.recv_getAmazonSearchResultCount()
4223 
 
4224 
  def send_getAmazonSearchResultCount(self, searchTerm):
4225 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4226 
    args = getAmazonSearchResultCount_args()
4227 
    args.searchTerm = searchTerm
4228 
    args.write(self._oprot)
4229 
    self._oprot.writeMessageEnd()
4230 
    self._oprot.trans.flush()
4231 
 
4232 
  def recv_getAmazonSearchResultCount(self, ):
4233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4234 
    if mtype == TMessageType.EXCEPTION:
4235 
      x = TApplicationException()
4236 
      x.read(self._iprot)
4237 
      self._iprot.readMessageEnd()
4238 
      raise x
4239 
    result = getAmazonSearchResultCount_result()
4240 
    result.read(self._iprot)
4241 
    self._iprot.readMessageEnd()
4242 
    if result.success is not None:
4243 
      return result.success
4244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4245 
 
4246 
  def getCountForAmazonlistedItems(self, ):
4247 
    self.send_getCountForAmazonlistedItems()
4248 
    return self.recv_getCountForAmazonlistedItems()
4249 
 
4250 
  def send_getCountForAmazonlistedItems(self, ):
4251 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4252 
    args = getCountForAmazonlistedItems_args()
4253 
    args.write(self._oprot)
4254 
    self._oprot.writeMessageEnd()
4255 
    self._oprot.trans.flush()
4256 
 
4257 
  def recv_getCountForAmazonlistedItems(self, ):
4258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4259 
    if mtype == TMessageType.EXCEPTION:
4260 
      x = TApplicationException()
4261 
      x.read(self._iprot)
4262 
      self._iprot.readMessageEnd()
4263 
      raise x
4264 
    result = getCountForAmazonlistedItems_result()
4265 
    result.read(self._iprot)
4266 
    self._iprot.readMessageEnd()
4267 
    if result.success is not None:
4268 
      return result.success
4269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4270 
 
7281 kshitij.so 4271 
  def getAmazonItemDetails(self, itemId):
4272 
    """
4273 
    Parameters:
4274 
     - itemId
4275 
    """
4276 
    self.send_getAmazonItemDetails(itemId)
4277 
    return self.recv_getAmazonItemDetails()
4278 
 
4279 
  def send_getAmazonItemDetails(self, itemId):
4280 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4281 
    args = getAmazonItemDetails_args()
4282 
    args.itemId = itemId
4283 
    args.write(self._oprot)
4284 
    self._oprot.writeMessageEnd()
4285 
    self._oprot.trans.flush()
4286 
 
4287 
  def recv_getAmazonItemDetails(self, ):
4288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4289 
    if mtype == TMessageType.EXCEPTION:
4290 
      x = TApplicationException()
4291 
      x.read(self._iprot)
4292 
      self._iprot.readMessageEnd()
4293 
      raise x
4294 
    result = getAmazonItemDetails_result()
4295 
    result.read(self._iprot)
4296 
    self._iprot.readMessageEnd()
4297 
    if result.success is not None:
4298 
      return result.success
4299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4300 
 
8168 kshitij.so 4301 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4302 
    """
4303 
    Parameters:
8168 kshitij.so 4304 
     - amazonlisted
7281 kshitij.so 4305 
    """
8168 kshitij.so 4306 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4307 
    self.recv_updateAmazonItemDetails()
4308 
 
8168 kshitij.so 4309 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4310 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4311 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4312 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4313 
    args.write(self._oprot)
4314 
    self._oprot.writeMessageEnd()
4315 
    self._oprot.trans.flush()
4316 
 
4317 
  def recv_updateAmazonItemDetails(self, ):
4318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4319 
    if mtype == TMessageType.EXCEPTION:
4320 
      x = TApplicationException()
4321 
      x.read(self._iprot)
4322 
      self._iprot.readMessageEnd()
4323 
      raise x
4324 
    result = updateAmazonItemDetails_result()
4325 
    result.read(self._iprot)
4326 
    self._iprot.readMessageEnd()
4327 
    return
4328 
 
4329 
  def addAmazonItem(self, amazonlisted):
4330 
    """
4331 
    Parameters:
4332 
     - amazonlisted
4333 
    """
4334 
    self.send_addAmazonItem(amazonlisted)
4335 
    self.recv_addAmazonItem()
4336 
 
4337 
  def send_addAmazonItem(self, amazonlisted):
4338 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4339 
    args = addAmazonItem_args()
4340 
    args.amazonlisted = amazonlisted
4341 
    args.write(self._oprot)
4342 
    self._oprot.writeMessageEnd()
4343 
    self._oprot.trans.flush()
4344 
 
4345 
  def recv_addAmazonItem(self, ):
4346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4347 
    if mtype == TMessageType.EXCEPTION:
4348 
      x = TApplicationException()
4349 
      x.read(self._iprot)
4350 
      self._iprot.readMessageEnd()
4351 
      raise x
4352 
    result = addAmazonItem_result()
4353 
    result.read(self._iprot)
4354 
    self._iprot.readMessageEnd()
4355 
    return
4356 
 
7291 vikram.rag 4357 
  def getAsinItems(self, ):
4358 
    self.send_getAsinItems()
4359 
    return self.recv_getAsinItems()
7281 kshitij.so 4360 
 
7291 vikram.rag 4361 
  def send_getAsinItems(self, ):
4362 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4363 
    args = getAsinItems_args()
4364 
    args.write(self._oprot)
4365 
    self._oprot.writeMessageEnd()
4366 
    self._oprot.trans.flush()
4367 
 
4368 
  def recv_getAsinItems(self, ):
4369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4370 
    if mtype == TMessageType.EXCEPTION:
4371 
      x = TApplicationException()
4372 
      x.read(self._iprot)
4373 
      self._iprot.readMessageEnd()
4374 
      raise x
4375 
    result = getAsinItems_result()
4376 
    result.read(self._iprot)
4377 
    self._iprot.readMessageEnd()
4378 
    if result.success is not None:
4379 
      return result.success
4380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4381 
 
4382 
  def getAllFbaListedItems(self, ):
4383 
    self.send_getAllFbaListedItems()
4384 
    return self.recv_getAllFbaListedItems()
4385 
 
4386 
  def send_getAllFbaListedItems(self, ):
4387 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4388 
    args = getAllFbaListedItems_args()
4389 
    args.write(self._oprot)
4390 
    self._oprot.writeMessageEnd()
4391 
    self._oprot.trans.flush()
4392 
 
4393 
  def recv_getAllFbaListedItems(self, ):
4394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4395 
    if mtype == TMessageType.EXCEPTION:
4396 
      x = TApplicationException()
4397 
      x.read(self._iprot)
4398 
      self._iprot.readMessageEnd()
4399 
      raise x
4400 
    result = getAllFbaListedItems_result()
4401 
    result.read(self._iprot)
4402 
    self._iprot.readMessageEnd()
4403 
    if result.success is not None:
4404 
      return result.success
4405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4406 
 
4407 
  def getAllNonFbaListedItems(self, ):
4408 
    self.send_getAllNonFbaListedItems()
4409 
    return self.recv_getAllNonFbaListedItems()
4410 
 
4411 
  def send_getAllNonFbaListedItems(self, ):
4412 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4413 
    args = getAllNonFbaListedItems_args()
4414 
    args.write(self._oprot)
4415 
    self._oprot.writeMessageEnd()
4416 
    self._oprot.trans.flush()
4417 
 
4418 
  def recv_getAllNonFbaListedItems(self, ):
4419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4420 
    if mtype == TMessageType.EXCEPTION:
4421 
      x = TApplicationException()
4422 
      x.read(self._iprot)
4423 
      self._iprot.readMessageEnd()
4424 
      raise x
4425 
    result = getAllNonFbaListedItems_result()
4426 
    result.read(self._iprot)
4427 
    self._iprot.readMessageEnd()
4428 
    if result.success is not None:
4429 
      return result.success
4430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4431 
 
7460 kshitij.so 4432 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4433 
    """
4434 
    Parameters:
4435 
     - itemId
4436 
     - holdInventory
4437 
     - defaultInventory
4438 
    """
4439 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4440 
    return self.recv_updateItemInventory()
7291 vikram.rag 4441 
 
7460 kshitij.so 4442 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4443 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4444 
    args = updateItemInventory_args()
4445 
    args.itemId = itemId
4446 
    args.holdInventory = holdInventory
4447 
    args.defaultInventory = defaultInventory
4448 
    args.write(self._oprot)
4449 
    self._oprot.writeMessageEnd()
4450 
    self._oprot.trans.flush()
4451 
 
4452 
  def recv_updateItemInventory(self, ):
4453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4454 
    if mtype == TMessageType.EXCEPTION:
4455 
      x = TApplicationException()
4456 
      x.read(self._iprot)
4457 
      self._iprot.readMessageEnd()
4458 
      raise x
4459 
    result = updateItemInventory_result()
4460 
    result.read(self._iprot)
4461 
    self._iprot.readMessageEnd()
4462 
    if result.success is not None:
4463 
      return result.success
4464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4465 
 
7770 kshitij.so 4466 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4467 
    """
4468 
    Parameters:
4469 
     - type
4470 
     - sku
4471 
     - timestamp
4472 
    """
4473 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4474 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4475 
 
7770 kshitij.so 4476 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4477 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4478 
    args = updateTimestampForAmazonFeeds_args()
4479 
    args.type = type
4480 
    args.sku = sku
4481 
    args.timestamp = timestamp
4482 
    args.write(self._oprot)
4483 
    self._oprot.writeMessageEnd()
4484 
    self._oprot.trans.flush()
4485 
 
4486 
  def recv_updateTimestampForAmazonFeeds(self, ):
4487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4488 
    if mtype == TMessageType.EXCEPTION:
4489 
      x = TApplicationException()
4490 
      x.read(self._iprot)
4491 
      self._iprot.readMessageEnd()
4492 
      raise x
4493 
    result = updateTimestampForAmazonFeeds_result()
4494 
    result.read(self._iprot)
4495 
    self._iprot.readMessageEnd()
4496 
    if result.success is not None:
4497 
      return result.success
4498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4499 
 
7897 amar.kumar 4500 
  def getAllParentCategories(self, ):
4501 
    self.send_getAllParentCategories()
4502 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4503 
 
7897 amar.kumar 4504 
  def send_getAllParentCategories(self, ):
4505 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4506 
    args = getAllParentCategories_args()
4507 
    args.write(self._oprot)
4508 
    self._oprot.writeMessageEnd()
4509 
    self._oprot.trans.flush()
4510 
 
4511 
  def recv_getAllParentCategories(self, ):
4512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4513 
    if mtype == TMessageType.EXCEPTION:
4514 
      x = TApplicationException()
4515 
      x.read(self._iprot)
4516 
      self._iprot.readMessageEnd()
4517 
      raise x
4518 
    result = getAllParentCategories_result()
4519 
    result.read(self._iprot)
4520 
    self._iprot.readMessageEnd()
4521 
    if result.success is not None:
4522 
      return result.success
4523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4524 
 
7977 kshitij.so 4525 
  def addPageViewEvent(self, pageViewEvents):
4526 
    """
4527 
    Parameters:
4528 
     - pageViewEvents
4529 
    """
4530 
    self.send_addPageViewEvent(pageViewEvents)
4531 
    self.recv_addPageViewEvent()
7897 amar.kumar 4532 
 
7977 kshitij.so 4533 
  def send_addPageViewEvent(self, pageViewEvents):
4534 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4535 
    args = addPageViewEvent_args()
4536 
    args.pageViewEvents = pageViewEvents
4537 
    args.write(self._oprot)
4538 
    self._oprot.writeMessageEnd()
4539 
    self._oprot.trans.flush()
4540 
 
4541 
  def recv_addPageViewEvent(self, ):
4542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4543 
    if mtype == TMessageType.EXCEPTION:
4544 
      x = TApplicationException()
4545 
      x.read(self._iprot)
4546 
      self._iprot.readMessageEnd()
4547 
      raise x
4548 
    result = addPageViewEvent_result()
4549 
    result.read(self._iprot)
4550 
    self._iprot.readMessageEnd()
4551 
    return
4552 
 
4553 
  def addCartEvent(self, cartEvents):
4554 
    """
4555 
    Parameters:
4556 
     - cartEvents
4557 
    """
4558 
    self.send_addCartEvent(cartEvents)
4559 
    self.recv_addCartEvent()
4560 
 
4561 
  def send_addCartEvent(self, cartEvents):
4562 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4563 
    args = addCartEvent_args()
4564 
    args.cartEvents = cartEvents
4565 
    args.write(self._oprot)
4566 
    self._oprot.writeMessageEnd()
4567 
    self._oprot.trans.flush()
4568 
 
4569 
  def recv_addCartEvent(self, ):
4570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4571 
    if mtype == TMessageType.EXCEPTION:
4572 
      x = TApplicationException()
4573 
      x.read(self._iprot)
4574 
      self._iprot.readMessageEnd()
4575 
      raise x
4576 
    result = addCartEvent_result()
4577 
    result.read(self._iprot)
4578 
    self._iprot.readMessageEnd()
4579 
    return
4580 
 
8182 amar.kumar 4581 
  def addEbayItem(self, ebayItem):
4582 
    """
4583 
    Parameters:
4584 
     - ebayItem
4585 
    """
4586 
    self.send_addEbayItem(ebayItem)
4587 
    self.recv_addEbayItem()
4588 
 
4589 
  def send_addEbayItem(self, ebayItem):
4590 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4591 
    args = addEbayItem_args()
4592 
    args.ebayItem = ebayItem
4593 
    args.write(self._oprot)
4594 
    self._oprot.writeMessageEnd()
4595 
    self._oprot.trans.flush()
4596 
 
4597 
  def recv_addEbayItem(self, ):
4598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4599 
    if mtype == TMessageType.EXCEPTION:
4600 
      x = TApplicationException()
4601 
      x.read(self._iprot)
4602 
      self._iprot.readMessageEnd()
4603 
      raise x
4604 
    result = addEbayItem_result()
4605 
    result.read(self._iprot)
4606 
    self._iprot.readMessageEnd()
4607 
    return
4608 
 
4609 
  def getEbayItem(self, listingId):
4610 
    """
4611 
    Parameters:
4612 
     - listingId
4613 
    """
4614 
    self.send_getEbayItem(listingId)
4615 
    return self.recv_getEbayItem()
4616 
 
4617 
  def send_getEbayItem(self, listingId):
4618 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4619 
    args = getEbayItem_args()
4620 
    args.listingId = listingId
4621 
    args.write(self._oprot)
4622 
    self._oprot.writeMessageEnd()
4623 
    self._oprot.trans.flush()
4624 
 
4625 
  def recv_getEbayItem(self, ):
4626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4627 
    if mtype == TMessageType.EXCEPTION:
4628 
      x = TApplicationException()
4629 
      x.read(self._iprot)
4630 
      self._iprot.readMessageEnd()
4631 
      raise x
4632 
    result = getEbayItem_result()
4633 
    result.read(self._iprot)
4634 
    self._iprot.readMessageEnd()
4635 
    if result.success is not None:
4636 
      return result.success
4637 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4638 
 
4639 
  def updateEbayItem(self, ebayItem):
4640 
    """
4641 
    Parameters:
4642 
     - ebayItem
4643 
    """
4644 
    self.send_updateEbayItem(ebayItem)
4645 
    self.recv_updateEbayItem()
4646 
 
4647 
  def send_updateEbayItem(self, ebayItem):
4648 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4649 
    args = updateEbayItem_args()
4650 
    args.ebayItem = ebayItem
4651 
    args.write(self._oprot)
4652 
    self._oprot.writeMessageEnd()
4653 
    self._oprot.trans.flush()
4654 
 
4655 
  def recv_updateEbayItem(self, ):
4656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4657 
    if mtype == TMessageType.EXCEPTION:
4658 
      x = TApplicationException()
4659 
      x.read(self._iprot)
4660 
      self._iprot.readMessageEnd()
4661 
      raise x
4662 
    result = updateEbayItem_result()
4663 
    result.read(self._iprot)
4664 
    self._iprot.readMessageEnd()
4665 
    return
4666 
 
8139 kshitij.so 4667 
  def getAmazonListedItems(self, offset, limit):
4668 
    """
4669 
    Parameters:
4670 
     - offset
4671 
     - limit
4672 
    """
4673 
    self.send_getAmazonListedItems(offset, limit)
4674 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4675 
 
8139 kshitij.so 4676 
  def send_getAmazonListedItems(self, offset, limit):
4677 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4678 
    args = getAmazonListedItems_args()
4679 
    args.offset = offset
4680 
    args.limit = limit
4681 
    args.write(self._oprot)
4682 
    self._oprot.writeMessageEnd()
4683 
    self._oprot.trans.flush()
4684 
 
4685 
  def recv_getAmazonListedItems(self, ):
4686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4687 
    if mtype == TMessageType.EXCEPTION:
4688 
      x = TApplicationException()
4689 
      x.read(self._iprot)
4690 
      self._iprot.readMessageEnd()
4691 
      raise x
4692 
    result = getAmazonListedItems_result()
4693 
    result.read(self._iprot)
4694 
    self._iprot.readMessageEnd()
4695 
    if result.success is not None:
4696 
      return result.success
4697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4698 
 
8168 kshitij.so 4699 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4700 
    """
4701 
    Parameters:
4702 
     - amazonlisted
4703 
    """
4704 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4705 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4706 
 
8168 kshitij.so 4707 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4708 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4709 
    args = updateAmazonAttributesInBulk_args()
4710 
    args.amazonlisted = amazonlisted
4711 
    args.write(self._oprot)
4712 
    self._oprot.writeMessageEnd()
4713 
    self._oprot.trans.flush()
4714 
 
4715 
  def recv_updateAmazonAttributesInBulk(self, ):
4716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4717 
    if mtype == TMessageType.EXCEPTION:
4718 
      x = TApplicationException()
4719 
      x.read(self._iprot)
4720 
      self._iprot.readMessageEnd()
4721 
      raise x
4722 
    result = updateAmazonAttributesInBulk_result()
4723 
    result.read(self._iprot)
4724 
    self._iprot.readMessageEnd()
4725 
    if result.success is not None:
4726 
      return result.success
4727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4728 
 
8379 vikram.rag 4729 
  def getAllItemstoListOnFba(self, ):
4730 
    self.send_getAllItemstoListOnFba()
4731 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4732 
 
8379 vikram.rag 4733 
  def send_getAllItemstoListOnFba(self, ):
4734 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4735 
    args = getAllItemstoListOnFba_args()
4736 
    args.write(self._oprot)
4737 
    self._oprot.writeMessageEnd()
4738 
    self._oprot.trans.flush()
4739 
 
4740 
  def recv_getAllItemstoListOnFba(self, ):
4741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4742 
    if mtype == TMessageType.EXCEPTION:
4743 
      x = TApplicationException()
4744 
      x.read(self._iprot)
4745 
      self._iprot.readMessageEnd()
4746 
      raise x
4747 
    result = getAllItemstoListOnFba_result()
4748 
    result.read(self._iprot)
4749 
    self._iprot.readMessageEnd()
4750 
    if result.success is not None:
4751 
      return result.success
4752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4753 
 
4754 
  def getAllItemstoListOnNonFba(self, ):
4755 
    self.send_getAllItemstoListOnNonFba()
4756 
    return self.recv_getAllItemstoListOnNonFba()
4757 
 
4758 
  def send_getAllItemstoListOnNonFba(self, ):
4759 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4760 
    args = getAllItemstoListOnNonFba_args()
4761 
    args.write(self._oprot)
4762 
    self._oprot.writeMessageEnd()
4763 
    self._oprot.trans.flush()
4764 
 
4765 
  def recv_getAllItemstoListOnNonFba(self, ):
4766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4767 
    if mtype == TMessageType.EXCEPTION:
4768 
      x = TApplicationException()
4769 
      x.read(self._iprot)
4770 
      self._iprot.readMessageEnd()
4771 
      raise x
4772 
    result = getAllItemstoListOnNonFba_result()
4773 
    result.read(self._iprot)
4774 
    self._iprot.readMessageEnd()
4775 
    if result.success is not None:
4776 
      return result.success
4777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4778 
 
8619 kshitij.so 4779 
  def updateAsin(self, item):
4780 
    """
4781 
    Parameters:
4782 
     - item
4783 
    """
4784 
    self.send_updateAsin(item)
4785 
    self.recv_updateAsin()
8616 vikram.rag 4786 
 
8619 kshitij.so 4787 
  def send_updateAsin(self, item):
4788 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4789 
    args = updateAsin_args()
4790 
    args.item = item
4791 
    args.write(self._oprot)
4792 
    self._oprot.writeMessageEnd()
4793 
    self._oprot.trans.flush()
4794 
 
4795 
  def recv_updateAsin(self, ):
4796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4797 
    if mtype == TMessageType.EXCEPTION:
4798 
      x = TApplicationException()
4799 
      x.read(self._iprot)
4800 
      self._iprot.readMessageEnd()
4801 
      raise x
4802 
    result = updateAsin_result()
4803 
    result.read(self._iprot)
4804 
    self._iprot.readMessageEnd()
4805 
    return
4806 
 
8739 vikram.rag 4807 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4808 
    """
4809 
    Parameters:
4810 
     - snapdealitem
4811 
    """
4812 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4813 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4814 
 
8739 vikram.rag 4815 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4816 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4817 
    args = addOrUpdateSnapdealItem_args()
4818 
    args.snapdealitem = snapdealitem
4819 
    args.write(self._oprot)
4820 
    self._oprot.writeMessageEnd()
4821 
    self._oprot.trans.flush()
4822 
 
4823 
  def recv_addOrUpdateSnapdealItem(self, ):
4824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4825 
    if mtype == TMessageType.EXCEPTION:
4826 
      x = TApplicationException()
4827 
      x.read(self._iprot)
4828 
      self._iprot.readMessageEnd()
4829 
      raise x
4830 
    result = addOrUpdateSnapdealItem_result()
4831 
    result.read(self._iprot)
4832 
    self._iprot.readMessageEnd()
4833 
    if result.success is not None:
4834 
      return result.success
4835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4836 
 
4837 
  def getSnapdealItem(self, item_id):
4838 
    """
4839 
    Parameters:
4840 
     - item_id
4841 
    """
4842 
    self.send_getSnapdealItem(item_id)
4843 
    return self.recv_getSnapdealItem()
4844 
 
4845 
  def send_getSnapdealItem(self, item_id):
4846 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4847 
    args = getSnapdealItem_args()
4848 
    args.item_id = item_id
4849 
    args.write(self._oprot)
4850 
    self._oprot.writeMessageEnd()
4851 
    self._oprot.trans.flush()
4852 
 
4853 
  def recv_getSnapdealItem(self, ):
4854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4855 
    if mtype == TMessageType.EXCEPTION:
4856 
      x = TApplicationException()
4857 
      x.read(self._iprot)
4858 
      self._iprot.readMessageEnd()
4859 
      raise x
4860 
    result = getSnapdealItem_result()
4861 
    result.read(self._iprot)
4862 
    self._iprot.readMessageEnd()
4863 
    if result.success is not None:
4864 
      return result.success
4865 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4866 
 
9242 kshitij.so 4867 
  def getSnapdealItemDetails(self, item_id):
4868 
    """
4869 
    Parameters:
4870 
     - item_id
4871 
    """
4872 
    self.send_getSnapdealItemDetails(item_id)
4873 
    return self.recv_getSnapdealItemDetails()
4874 
 
4875 
  def send_getSnapdealItemDetails(self, item_id):
4876 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
4877 
    args = getSnapdealItemDetails_args()
4878 
    args.item_id = item_id
4879 
    args.write(self._oprot)
4880 
    self._oprot.writeMessageEnd()
4881 
    self._oprot.trans.flush()
4882 
 
4883 
  def recv_getSnapdealItemDetails(self, ):
4884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4885 
    if mtype == TMessageType.EXCEPTION:
4886 
      x = TApplicationException()
4887 
      x.read(self._iprot)
4888 
      self._iprot.readMessageEnd()
4889 
      raise x
4890 
    result = getSnapdealItemDetails_result()
4891 
    result.read(self._iprot)
4892 
    self._iprot.readMessageEnd()
4893 
    if result.success is not None:
4894 
      return result.success
4895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
4896 
 
8739 vikram.rag 4897 
  def getAllSnapdealItems(self, ):
4898 
    self.send_getAllSnapdealItems()
4899 
    return self.recv_getAllSnapdealItems()
4900 
 
4901 
  def send_getAllSnapdealItems(self, ):
4902 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4903 
    args = getAllSnapdealItems_args()
4904 
    args.write(self._oprot)
4905 
    self._oprot.writeMessageEnd()
4906 
    self._oprot.trans.flush()
4907 
 
4908 
  def recv_getAllSnapdealItems(self, ):
4909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4910 
    if mtype == TMessageType.EXCEPTION:
4911 
      x = TApplicationException()
4912 
      x.read(self._iprot)
4913 
      self._iprot.readMessageEnd()
4914 
      raise x
4915 
    result = getAllSnapdealItems_result()
4916 
    result.read(self._iprot)
4917 
    self._iprot.readMessageEnd()
4918 
    if result.success is not None:
4919 
      return result.success
4920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4921 
 
9242 kshitij.so 4922 
  def getSnapdealItems(self, offset, limit):
4923 
    """
4924 
    Parameters:
4925 
     - offset
4926 
     - limit
4927 
    """
4928 
    self.send_getSnapdealItems(offset, limit)
4929 
    return self.recv_getSnapdealItems()
8739 vikram.rag 4930 
 
9242 kshitij.so 4931 
  def send_getSnapdealItems(self, offset, limit):
4932 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
4933 
    args = getSnapdealItems_args()
4934 
    args.offset = offset
4935 
    args.limit = limit
4936 
    args.write(self._oprot)
4937 
    self._oprot.writeMessageEnd()
4938 
    self._oprot.trans.flush()
4939 
 
4940 
  def recv_getSnapdealItems(self, ):
4941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4942 
    if mtype == TMessageType.EXCEPTION:
4943 
      x = TApplicationException()
4944 
      x.read(self._iprot)
4945 
      self._iprot.readMessageEnd()
4946 
      raise x
4947 
    result = getSnapdealItems_result()
4948 
    result.read(self._iprot)
4949 
    self._iprot.readMessageEnd()
4950 
    if result.success is not None:
4951 
      return result.success
4952 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
4953 
 
4954 
  def searchSnapdealItems(self, searchTerm, offset, limit):
4955 
    """
4956 
    Parameters:
4957 
     - searchTerm
4958 
     - offset
4959 
     - limit
4960 
    """
4961 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
4962 
    return self.recv_searchSnapdealItems()
4963 
 
4964 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
4965 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
4966 
    args = searchSnapdealItems_args()
4967 
    args.searchTerm = searchTerm
4968 
    args.offset = offset
4969 
    args.limit = limit
4970 
    args.write(self._oprot)
4971 
    self._oprot.writeMessageEnd()
4972 
    self._oprot.trans.flush()
4973 
 
4974 
  def recv_searchSnapdealItems(self, ):
4975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4976 
    if mtype == TMessageType.EXCEPTION:
4977 
      x = TApplicationException()
4978 
      x.read(self._iprot)
4979 
      self._iprot.readMessageEnd()
4980 
      raise x
4981 
    result = searchSnapdealItems_result()
4982 
    result.read(self._iprot)
4983 
    self._iprot.readMessageEnd()
4984 
    if result.success is not None:
4985 
      return result.success
4986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
4987 
 
4988 
  def getCountForSnapdealItems(self, ):
4989 
    self.send_getCountForSnapdealItems()
4990 
    return self.recv_getCountForSnapdealItems()
4991 
 
4992 
  def send_getCountForSnapdealItems(self, ):
4993 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
4994 
    args = getCountForSnapdealItems_args()
4995 
    args.write(self._oprot)
4996 
    self._oprot.writeMessageEnd()
4997 
    self._oprot.trans.flush()
4998 
 
4999 
  def recv_getCountForSnapdealItems(self, ):
5000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5001 
    if mtype == TMessageType.EXCEPTION:
5002 
      x = TApplicationException()
5003 
      x.read(self._iprot)
5004 
      self._iprot.readMessageEnd()
5005 
      raise x
5006 
    result = getCountForSnapdealItems_result()
5007 
    result.read(self._iprot)
5008 
    self._iprot.readMessageEnd()
5009 
    if result.success is not None:
5010 
      return result.success
5011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5012 
 
5013 
  def getSnapdealSearchResultCount(self, searchTerm):
5014 
    """
5015 
    Parameters:
5016 
     - searchTerm
5017 
    """
5018 
    self.send_getSnapdealSearchResultCount(searchTerm)
5019 
    return self.recv_getSnapdealSearchResultCount()
5020 
 
5021 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5022 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5023 
    args = getSnapdealSearchResultCount_args()
5024 
    args.searchTerm = searchTerm
5025 
    args.write(self._oprot)
5026 
    self._oprot.writeMessageEnd()
5027 
    self._oprot.trans.flush()
5028 
 
5029 
  def recv_getSnapdealSearchResultCount(self, ):
5030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5031 
    if mtype == TMessageType.EXCEPTION:
5032 
      x = TApplicationException()
5033 
      x.read(self._iprot)
5034 
      self._iprot.readMessageEnd()
5035 
      raise x
5036 
    result = getSnapdealSearchResultCount_result()
5037 
    result.read(self._iprot)
5038 
    self._iprot.readMessageEnd()
5039 
    if result.success is not None:
5040 
      return result.success
5041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5042 
 
9299 kshitij.so 5043 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5044 
    """
5045 
    Parameters:
5046 
     - itemId
5047 
     - insurerType
5048 
    """
5049 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5050 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5051 
 
9299 kshitij.so 5052 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5053 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5054 
    args = getPrefferedInsurerForItem_args()
5055 
    args.itemId = itemId
5056 
    args.insurerType = insurerType
5057 
    args.write(self._oprot)
5058 
    self._oprot.writeMessageEnd()
5059 
    self._oprot.trans.flush()
5060 
 
5061 
  def recv_getPrefferedInsurerForItem(self, ):
5062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5063 
    if mtype == TMessageType.EXCEPTION:
5064 
      x = TApplicationException()
5065 
      x.read(self._iprot)
5066 
      self._iprot.readMessageEnd()
5067 
      raise x
5068 
    result = getPrefferedInsurerForItem_result()
5069 
    result.read(self._iprot)
5070 
    self._iprot.readMessageEnd()
5071 
    if result.success is not None:
5072 
      return result.success
5073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5074 
 
9456 vikram.rag 5075 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5076 
    """
5077 
    Parameters:
5078 
     - skuAtSnapdeal
5079 
    """
5080 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5081 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5082 
 
9456 vikram.rag 5083 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5084 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5085 
    args = getSnapdealItembySkuAtSnapdeal_args()
5086 
    args.skuAtSnapdeal = skuAtSnapdeal
5087 
    args.write(self._oprot)
5088 
    self._oprot.writeMessageEnd()
5089 
    self._oprot.trans.flush()
5090 
 
5091 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5093 
    if mtype == TMessageType.EXCEPTION:
5094 
      x = TApplicationException()
5095 
      x.read(self._iprot)
5096 
      self._iprot.readMessageEnd()
5097 
      raise x
5098 
    result = getSnapdealItembySkuAtSnapdeal_result()
5099 
    result.read(self._iprot)
5100 
    self._iprot.readMessageEnd()
5101 
    if result.success is not None:
5102 
      return result.success
5103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5104 
 
9621 manish.sha 5105 
  def getProductFeedSubmit(self, catalogItemId):
5106 
    """
5107 
    Parameters:
5108 
     - catalogItemId
5109 
    """
5110 
    self.send_getProductFeedSubmit(catalogItemId)
5111 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5112 
 
9621 manish.sha 5113 
  def send_getProductFeedSubmit(self, catalogItemId):
5114 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5115 
    args = getProductFeedSubmit_args()
5116 
    args.catalogItemId = catalogItemId
5117 
    args.write(self._oprot)
5118 
    self._oprot.writeMessageEnd()
5119 
    self._oprot.trans.flush()
5120 
 
5121 
  def recv_getProductFeedSubmit(self, ):
5122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5123 
    if mtype == TMessageType.EXCEPTION:
5124 
      x = TApplicationException()
5125 
      x.read(self._iprot)
5126 
      self._iprot.readMessageEnd()
5127 
      raise x
5128 
    result = getProductFeedSubmit_result()
5129 
    result.read(self._iprot)
5130 
    self._iprot.readMessageEnd()
5131 
    if result.success is not None:
5132 
      return result.success
5133 
    if result.cex is not None:
5134 
      raise result.cex
5135 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5136 
 
5137 
  def addProductFeedSubmit(self, productFeedSubmit):
5138 
    """
5139 
    Parameters:
5140 
     - productFeedSubmit
5141 
    """
5142 
    self.send_addProductFeedSubmit(productFeedSubmit)
5143 
    return self.recv_addProductFeedSubmit()
5144 
 
5145 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5146 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5147 
    args = addProductFeedSubmit_args()
5148 
    args.productFeedSubmit = productFeedSubmit
5149 
    args.write(self._oprot)
5150 
    self._oprot.writeMessageEnd()
5151 
    self._oprot.trans.flush()
5152 
 
5153 
  def recv_addProductFeedSubmit(self, ):
5154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5155 
    if mtype == TMessageType.EXCEPTION:
5156 
      x = TApplicationException()
5157 
      x.read(self._iprot)
5158 
      self._iprot.readMessageEnd()
5159 
      raise x
5160 
    result = addProductFeedSubmit_result()
5161 
    result.read(self._iprot)
5162 
    self._iprot.readMessageEnd()
5163 
    if result.success is not None:
5164 
      return result.success
5165 
    if result.cex is not None:
5166 
      raise result.cex
5167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5168 
 
5169 
  def updateProductFeedSubmit(self, productFeedSubmit):
5170 
    """
5171 
    Parameters:
5172 
     - productFeedSubmit
5173 
    """
5174 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5175 
    return self.recv_updateProductFeedSubmit()
5176 
 
5177 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5178 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5179 
    args = updateProductFeedSubmit_args()
5180 
    args.productFeedSubmit = productFeedSubmit
5181 
    args.write(self._oprot)
5182 
    self._oprot.writeMessageEnd()
5183 
    self._oprot.trans.flush()
5184 
 
5185 
  def recv_updateProductFeedSubmit(self, ):
5186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5187 
    if mtype == TMessageType.EXCEPTION:
5188 
      x = TApplicationException()
5189 
      x.read(self._iprot)
5190 
      self._iprot.readMessageEnd()
5191 
      raise x
5192 
    result = updateProductFeedSubmit_result()
5193 
    result.read(self._iprot)
5194 
    self._iprot.readMessageEnd()
5195 
    if result.success is not None:
5196 
      return result.success
5197 
    if result.cex is not None:
5198 
      raise result.cex
5199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5200 
 
5201 
  def deleteProductFeedSubmit(self, catalogItemId):
5202 
    """
5203 
    Parameters:
5204 
     - catalogItemId
5205 
    """
5206 
    self.send_deleteProductFeedSubmit(catalogItemId)
5207 
    return self.recv_deleteProductFeedSubmit()
5208 
 
5209 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5210 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5211 
    args = deleteProductFeedSubmit_args()
5212 
    args.catalogItemId = catalogItemId
5213 
    args.write(self._oprot)
5214 
    self._oprot.writeMessageEnd()
5215 
    self._oprot.trans.flush()
5216 
 
5217 
  def recv_deleteProductFeedSubmit(self, ):
5218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5219 
    if mtype == TMessageType.EXCEPTION:
5220 
      x = TApplicationException()
5221 
      x.read(self._iprot)
5222 
      self._iprot.readMessageEnd()
5223 
      raise x
5224 
    result = deleteProductFeedSubmit_result()
5225 
    result.read(self._iprot)
5226 
    self._iprot.readMessageEnd()
5227 
    if result.success is not None:
5228 
      return result.success
5229 
    if result.cex is not None:
5230 
      raise result.cex
5231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5232 
 
5233 
  def getAllProductFeedSubmit(self, ):
5234 
    self.send_getAllProductFeedSubmit()
5235 
    return self.recv_getAllProductFeedSubmit()
5236 
 
5237 
  def send_getAllProductFeedSubmit(self, ):
5238 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5239 
    args = getAllProductFeedSubmit_args()
5240 
    args.write(self._oprot)
5241 
    self._oprot.writeMessageEnd()
5242 
    self._oprot.trans.flush()
5243 
 
5244 
  def recv_getAllProductFeedSubmit(self, ):
5245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5246 
    if mtype == TMessageType.EXCEPTION:
5247 
      x = TApplicationException()
5248 
      x.read(self._iprot)
5249 
      self._iprot.readMessageEnd()
5250 
      raise x
5251 
    result = getAllProductFeedSubmit_result()
5252 
    result.read(self._iprot)
5253 
    self._iprot.readMessageEnd()
5254 
    if result.success is not None:
5255 
      return result.success
5256 
    if result.cex is not None:
5257 
      raise result.cex
5258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5259 
 
9724 kshitij.so 5260 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5261 
    """
5262 
    Parameters:
5263 
     - itemId
5264 
     - sourceId
5265 
    """
5266 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5267 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5268 
 
9724 kshitij.so 5269 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5270 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5271 
    args = getMarketplacedetailsForItem_args()
5272 
    args.itemId = itemId
5273 
    args.sourceId = sourceId
5274 
    args.write(self._oprot)
5275 
    self._oprot.writeMessageEnd()
5276 
    self._oprot.trans.flush()
5277 
 
5278 
  def recv_getMarketplacedetailsForItem(self, ):
5279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5280 
    if mtype == TMessageType.EXCEPTION:
5281 
      x = TApplicationException()
5282 
      x.read(self._iprot)
5283 
      self._iprot.readMessageEnd()
5284 
      raise x
5285 
    result = getMarketplacedetailsForItem_result()
5286 
    result.read(self._iprot)
5287 
    self._iprot.readMessageEnd()
5288 
    if result.success is not None:
5289 
      return result.success
5290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5291 
 
5292 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5293 
    """
5294 
    Parameters:
5295 
     - marketPlaceItem
5296 
    """
5297 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5298 
    return self.recv_updateMarketplaceAttributesForItem()
5299 
 
5300 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5301 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5302 
    args = updateMarketplaceAttributesForItem_args()
5303 
    args.marketPlaceItem = marketPlaceItem
5304 
    args.write(self._oprot)
5305 
    self._oprot.writeMessageEnd()
5306 
    self._oprot.trans.flush()
5307 
 
5308 
  def recv_updateMarketplaceAttributesForItem(self, ):
5309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5310 
    if mtype == TMessageType.EXCEPTION:
5311 
      x = TApplicationException()
5312 
      x.read(self._iprot)
5313 
      self._iprot.readMessageEnd()
5314 
      raise x
5315 
    result = updateMarketplaceAttributesForItem_result()
5316 
    result.read(self._iprot)
5317 
    self._iprot.readMessageEnd()
5318 
    if result.success is not None:
5319 
      return result.success
5320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5321 
 
9779 kshitij.so 5322 
  def getCostingForMarketplace(self, source, item_id):
5323 
    """
5324 
    Parameters:
5325 
     - source
5326 
     - item_id
5327 
    """
5328 
    self.send_getCostingForMarketplace(source, item_id)
5329 
    return self.recv_getCostingForMarketplace()
5330 
 
5331 
  def send_getCostingForMarketplace(self, source, item_id):
5332 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5333 
    args = getCostingForMarketplace_args()
5334 
    args.source = source
5335 
    args.item_id = item_id
5336 
    args.write(self._oprot)
5337 
    self._oprot.writeMessageEnd()
5338 
    self._oprot.trans.flush()
5339 
 
5340 
  def recv_getCostingForMarketplace(self, ):
5341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5342 
    if mtype == TMessageType.EXCEPTION:
5343 
      x = TApplicationException()
5344 
      x.read(self._iprot)
5345 
      self._iprot.readMessageEnd()
5346 
      raise x
5347 
    result = getCostingForMarketplace_result()
5348 
    result.read(self._iprot)
5349 
    self._iprot.readMessageEnd()
5350 
    if result.success is not None:
5351 
      return result.success
5352 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5353 
 
9776 vikram.rag 5354 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5355 
    """
5356 
    Parameters:
5357 
     - source
5358 
    """
5359 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5360 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5361 
 
9776 vikram.rag 5362 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5363 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5364 
    args = getMarketPlaceItemsForPriceUpdate_args()
5365 
    args.source = source
5366 
    args.write(self._oprot)
5367 
    self._oprot.writeMessageEnd()
5368 
    self._oprot.trans.flush()
5369 
 
5370 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5372 
    if mtype == TMessageType.EXCEPTION:
5373 
      x = TApplicationException()
5374 
      x.read(self._iprot)
5375 
      self._iprot.readMessageEnd()
5376 
      raise x
5377 
    result = getMarketPlaceItemsForPriceUpdate_result()
5378 
    result.read(self._iprot)
5379 
    self._iprot.readMessageEnd()
5380 
    if result.success is not None:
5381 
      return result.success
5382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5383 
 
9816 kshitij.so 5384 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5385 
    """
5386 
    Parameters:
5387 
     - skulist
5388 
     - timestamp
9816 kshitij.so 5389 
     - source
9776 vikram.rag 5390 
    """
9816 kshitij.so 5391 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5392 
    self.recv_updateMarketPlacePriceUpdateStatus()
5393 
 
9816 kshitij.so 5394 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5395 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5396 
    args = updateMarketPlacePriceUpdateStatus_args()
5397 
    args.skulist = skulist
5398 
    args.timestamp = timestamp
9816 kshitij.so 5399 
    args.source = source
9776 vikram.rag 5400 
    args.write(self._oprot)
5401 
    self._oprot.writeMessageEnd()
5402 
    self._oprot.trans.flush()
5403 
 
5404 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5406 
    if mtype == TMessageType.EXCEPTION:
5407 
      x = TApplicationException()
5408 
      x.read(self._iprot)
5409 
      self._iprot.readMessageEnd()
5410 
      raise x
5411 
    result = updateMarketPlacePriceUpdateStatus_result()
5412 
    result.read(self._iprot)
5413 
    self._iprot.readMessageEnd()
5414 
    return
5415 
 
9861 rajveer 5416 
  def updateItemHoldInventory(self, itemHoldMap):
5417 
    """
5418 
    Parameters:
5419 
     - itemHoldMap
5420 
    """
5421 
    self.send_updateItemHoldInventory(itemHoldMap)
5422 
    self.recv_updateItemHoldInventory()
9776 vikram.rag 5423 
 
9861 rajveer 5424 
  def send_updateItemHoldInventory(self, itemHoldMap):
5425 
    self._oprot.writeMessageBegin('updateItemHoldInventory', TMessageType.CALL, self._seqid)
5426 
    args = updateItemHoldInventory_args()
5427 
    args.itemHoldMap = itemHoldMap
5428 
    args.write(self._oprot)
5429 
    self._oprot.writeMessageEnd()
5430 
    self._oprot.trans.flush()
5431 
 
5432 
  def recv_updateItemHoldInventory(self, ):
5433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5434 
    if mtype == TMessageType.EXCEPTION:
5435 
      x = TApplicationException()
5436 
      x.read(self._iprot)
5437 
      self._iprot.readMessageEnd()
5438 
      raise x
5439 
    result = updateItemHoldInventory_result()
5440 
    result.read(self._iprot)
5441 
    self._iprot.readMessageEnd()
5442 
    return
5443 
 
5444 
 
5944 mandeep.dh 5445 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
5446 
  def __init__(self, handler):
5447 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
5448 
    self._processMap["addItem"] = Processor.process_addItem
5449 
    self._processMap["updateItem"] = Processor.process_updateItem
5450 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 5451 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 5452 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
5453 
    self._processMap["startItemOn"] = Processor.process_startItemOn
5454 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
5455 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
5456 
    self._processMap["getItem"] = Processor.process_getItem
5457 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
5458 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
5459 
    self._processMap["getAllItems"] = Processor.process_getAllItems
5460 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
5461 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
5462 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
5463 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
5464 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
5465 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
5466 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
5467 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
5468 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
5469 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
5470 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
5471 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
5472 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
5473 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
5474 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
5475 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
5476 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
5477 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
5478 
    self._processMap["addCategory"] = Processor.process_addCategory
5479 
    self._processMap["getCategory"] = Processor.process_getCategory
5480 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
5481 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
5482 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 5483 
    self._processMap["addTag"] = Processor.process_addTag
5484 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
5485 
    self._processMap["deleteTag"] = Processor.process_deleteTag
5486 
    self._processMap["getAllTags"] = Processor.process_getAllTags
5487 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 5488 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 5489 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 5490 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 5491 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
5492 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
5493 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
5494 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 5495 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 5496 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 5497 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
5498 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 5499 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
5500 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
5501 
    self._processMap["addCampaign"] = Processor.process_addCampaign
5502 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
5503 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
5504 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 5505 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 5506 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
5507 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
5508 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
5509 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
5510 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
5511 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
5512 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
5513 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
5514 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
5515 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
5516 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
5517 
    self._processMap["getAllSources"] = Processor.process_getAllSources
5518 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
5519 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
5520 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
5521 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
5522 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
5523 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
5524 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
5525 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
5526 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
5527 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
5528 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
5529 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
5530 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
5531 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 5532 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
5533 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 5534 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 5535 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 5536 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
5537 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 5538 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 5539 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 5540 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
5541 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 5542 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
5543 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 5544 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 5545 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 5546 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 5547 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 5548 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
5549 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
5550 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 5551 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
5552 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
5553 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 5554 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
5555 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
5556 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 5557 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 5558 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 5559 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 5560 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
5561 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 5562 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
5563 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
5564 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 5565 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 5566 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 5567 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
5568 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 5569 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 5570 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
5571 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 5572 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 5573 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 5574 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
5575 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
5576 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
5577 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 5578 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 5579 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 5580 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
5581 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
5582 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
5583 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
5584 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 5585 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
5586 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 5587 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 5588 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
5589 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
9861 rajveer 5590 
    self._processMap["updateItemHoldInventory"] = Processor.process_updateItemHoldInventory
5944 mandeep.dh 5591 
 
5592 
  def process(self, iprot, oprot):
5593 
    (name, type, seqid) = iprot.readMessageBegin()
5594 
    if name not in self._processMap:
5595 
      iprot.skip(TType.STRUCT)
5596 
      iprot.readMessageEnd()
5597 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5598 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5599 
      x.write(oprot)
5600 
      oprot.writeMessageEnd()
5601 
      oprot.trans.flush()
5602 
      return
5603 
    else:
5604 
      self._processMap[name](self, seqid, iprot, oprot)
5605 
    return True
5606 
 
5607 
  def process_addItem(self, seqid, iprot, oprot):
5608 
    args = addItem_args()
5609 
    args.read(iprot)
5610 
    iprot.readMessageEnd()
5611 
    result = addItem_result()
5612 
    try:
5613 
      result.success = self._handler.addItem(args.item)
5614 
    except CatalogServiceException, cex:
5615 
      result.cex = cex
5616 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
5617 
    result.write(oprot)
5618 
    oprot.writeMessageEnd()
5619 
    oprot.trans.flush()
5620 
 
5621 
  def process_updateItem(self, seqid, iprot, oprot):
5622 
    args = updateItem_args()
5623 
    args.read(iprot)
5624 
    iprot.readMessageEnd()
5625 
    result = updateItem_result()
5626 
    try:
5627 
      result.success = self._handler.updateItem(args.item)
5628 
    except CatalogServiceException, cex:
5629 
      result.cex = cex
5630 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
5631 
    result.write(oprot)
5632 
    oprot.writeMessageEnd()
5633 
    oprot.trans.flush()
5634 
 
5635 
  def process_isActive(self, seqid, iprot, oprot):
5636 
    args = isActive_args()
5637 
    args.read(iprot)
5638 
    iprot.readMessageEnd()
5639 
    result = isActive_result()
5640 
    try:
5641 
      result.success = self._handler.isActive(args.itemId)
5642 
    except CatalogServiceException, isex:
5643 
      result.isex = isex
5644 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
5645 
    result.write(oprot)
5646 
    oprot.writeMessageEnd()
5647 
    oprot.trans.flush()
5648 
 
7438 amit.gupta 5649 
  def process_getItemsStatus(self, seqid, iprot, oprot):
5650 
    args = getItemsStatus_args()
5651 
    args.read(iprot)
5652 
    iprot.readMessageEnd()
5653 
    result = getItemsStatus_result()
5654 
    try:
5655 
      result.success = self._handler.getItemsStatus(args.itemIds)
5656 
    except CatalogServiceException, isex:
5657 
      result.isex = isex
5658 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
5659 
    result.write(oprot)
5660 
    oprot.writeMessageEnd()
5661 
    oprot.trans.flush()
5662 
 
5944 mandeep.dh 5663 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
5664 
    args = getItemStatusDescription_args()
5665 
    args.read(iprot)
5666 
    iprot.readMessageEnd()
5667 
    result = getItemStatusDescription_result()
5668 
    try:
5669 
      result.success = self._handler.getItemStatusDescription(args.itemId)
5670 
    except CatalogServiceException, isex:
5671 
      result.isex = isex
5672 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
5673 
    result.write(oprot)
5674 
    oprot.writeMessageEnd()
5675 
    oprot.trans.flush()
5676 
 
5677 
  def process_startItemOn(self, seqid, iprot, oprot):
5678 
    args = startItemOn_args()
5679 
    args.read(iprot)
5680 
    iprot.readMessageEnd()
5681 
    result = startItemOn_result()
5682 
    try:
5683 
      self._handler.startItemOn(args.item_id, args.timestamp)
5684 
    except CatalogServiceException, cex:
5685 
      result.cex = cex
5686 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
5687 
    result.write(oprot)
5688 
    oprot.writeMessageEnd()
5689 
    oprot.trans.flush()
5690 
 
5691 
  def process_retireItemOn(self, seqid, iprot, oprot):
5692 
    args = retireItemOn_args()
5693 
    args.read(iprot)
5694 
    iprot.readMessageEnd()
5695 
    result = retireItemOn_result()
5696 
    try:
5697 
      self._handler.retireItemOn(args.item_id, args.timestamp)
5698 
    except CatalogServiceException, cex:
5699 
      result.cex = cex
5700 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
5701 
    result.write(oprot)
5702 
    oprot.writeMessageEnd()
5703 
    oprot.trans.flush()
5704 
 
5705 
  def process_changeItemStatus(self, seqid, iprot, oprot):
5706 
    args = changeItemStatus_args()
5707 
    args.read(iprot)
5708 
    iprot.readMessageEnd()
5709 
    result = changeItemStatus_result()
5710 
    try:
5711 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
5712 
    except CatalogServiceException, cex:
5713 
      result.cex = cex
5714 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
5715 
    result.write(oprot)
5716 
    oprot.writeMessageEnd()
5717 
    oprot.trans.flush()
5718 
 
5719 
  def process_getItem(self, seqid, iprot, oprot):
5720 
    args = getItem_args()
5721 
    args.read(iprot)
5722 
    iprot.readMessageEnd()
5723 
    result = getItem_result()
5724 
    try:
5725 
      result.success = self._handler.getItem(args.item_id)
5726 
    except CatalogServiceException, cex:
5727 
      result.cex = cex
5728 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
5729 
    result.write(oprot)
5730 
    oprot.writeMessageEnd()
5731 
    oprot.trans.flush()
5732 
 
5733 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
5734 
    args = getItemsByCatalogId_args()
5735 
    args.read(iprot)
5736 
    iprot.readMessageEnd()
5737 
    result = getItemsByCatalogId_result()
5738 
    try:
5739 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
5740 
    except CatalogServiceException, cex:
5741 
      result.cex = cex
5742 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
5743 
    result.write(oprot)
5744 
    oprot.writeMessageEnd()
5745 
    oprot.trans.flush()
5746 
 
5747 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
5748 
    args = getValidItemsByCatalogId_args()
5749 
    args.read(iprot)
5750 
    iprot.readMessageEnd()
5751 
    result = getValidItemsByCatalogId_result()
5752 
    try:
5753 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
5754 
    except CatalogServiceException, cex:
5755 
      result.cex = cex
5756 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
5757 
    result.write(oprot)
5758 
    oprot.writeMessageEnd()
5759 
    oprot.trans.flush()
5760 
 
5761 
  def process_getAllItems(self, seqid, iprot, oprot):
5762 
    args = getAllItems_args()
5763 
    args.read(iprot)
5764 
    iprot.readMessageEnd()
5765 
    result = getAllItems_result()
5766 
    try:
5767 
      result.success = self._handler.getAllItems(args.isActive)
5768 
    except CatalogServiceException, cex:
5769 
      result.cex = cex
5770 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
5771 
    result.write(oprot)
5772 
    oprot.writeMessageEnd()
5773 
    oprot.trans.flush()
5774 
 
5775 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
5776 
    args = getAllItemsByStatus_args()
5777 
    args.read(iprot)
5778 
    iprot.readMessageEnd()
5779 
    result = getAllItemsByStatus_result()
5780 
    try:
5781 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
5782 
    except CatalogServiceException, cex:
5783 
      result.cex = cex
5784 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
5785 
    result.write(oprot)
5786 
    oprot.writeMessageEnd()
5787 
    oprot.trans.flush()
5788 
 
5789 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
5790 
    args = markItemAsContentComplete_args()
5791 
    args.read(iprot)
5792 
    iprot.readMessageEnd()
5793 
    result = markItemAsContentComplete_result()
5794 
    try:
9253 rajveer 5795 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 5796 
    except CatalogServiceException, cex:
5797 
      result.cex = cex
5798 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
5799 
    result.write(oprot)
5800 
    oprot.writeMessageEnd()
5801 
    oprot.trans.flush()
5802 
 
5803 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
5804 
    args = getAllItemsInRange_args()
5805 
    args.read(iprot)
5806 
    iprot.readMessageEnd()
5807 
    result = getAllItemsInRange_result()
5808 
    try:
5809 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
5810 
    except CatalogServiceException, cex:
5811 
      result.cex = cex
5812 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
5813 
    result.write(oprot)
5814 
    oprot.writeMessageEnd()
5815 
    oprot.trans.flush()
5816 
 
5817 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
5818 
    args = getAllItemsByStatusInRange_args()
5819 
    args.read(iprot)
5820 
    iprot.readMessageEnd()
5821 
    result = getAllItemsByStatusInRange_result()
5822 
    try:
5823 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
5824 
    except CatalogServiceException, cex:
5825 
      result.cex = cex
5826 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
5827 
    result.write(oprot)
5828 
    oprot.writeMessageEnd()
5829 
    oprot.trans.flush()
5830 
 
5831 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
5832 
    args = getItemCountByStatus_args()
5833 
    args.read(iprot)
5834 
    iprot.readMessageEnd()
5835 
    result = getItemCountByStatus_result()
5836 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
5837 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
5838 
    result.write(oprot)
5839 
    oprot.writeMessageEnd()
5840 
    oprot.trans.flush()
5841 
 
5842 
  def process_getBestSellers(self, seqid, iprot, oprot):
5843 
    args = getBestSellers_args()
5844 
    args.read(iprot)
5845 
    iprot.readMessageEnd()
5846 
    result = getBestSellers_result()
5847 
    try:
5848 
      result.success = self._handler.getBestSellers()
5849 
    except CatalogServiceException, isex:
5850 
      result.isex = isex
5851 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
5852 
    result.write(oprot)
5853 
    oprot.writeMessageEnd()
5854 
    oprot.trans.flush()
5855 
 
5856 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
5857 
    args = getBestSellersCatalogIds_args()
5858 
    args.read(iprot)
5859 
    iprot.readMessageEnd()
5860 
    result = getBestSellersCatalogIds_result()
5861 
    try:
5862 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5863 
    except CatalogServiceException, cex:
5864 
      result.cex = cex
5865 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
5866 
    result.write(oprot)
5867 
    oprot.writeMessageEnd()
5868 
    oprot.trans.flush()
5869 
 
5870 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
5871 
    args = getBestSellersCount_args()
5872 
    args.read(iprot)
5873 
    iprot.readMessageEnd()
5874 
    result = getBestSellersCount_result()
5875 
    try:
5876 
      result.success = self._handler.getBestSellersCount()
5877 
    except CatalogServiceException, cex:
5878 
      result.cex = cex
5879 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
5880 
    result.write(oprot)
5881 
    oprot.writeMessageEnd()
5882 
    oprot.trans.flush()
5883 
 
5884 
  def process_getBestDeals(self, seqid, iprot, oprot):
5885 
    args = getBestDeals_args()
5886 
    args.read(iprot)
5887 
    iprot.readMessageEnd()
5888 
    result = getBestDeals_result()
5889 
    try:
5890 
      result.success = self._handler.getBestDeals()
5891 
    except CatalogServiceException, isex:
5892 
      result.isex = isex
5893 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
5894 
    result.write(oprot)
5895 
    oprot.writeMessageEnd()
5896 
    oprot.trans.flush()
5897 
 
5898 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
5899 
    args = getBestDealsCatalogIds_args()
5900 
    args.read(iprot)
5901 
    iprot.readMessageEnd()
5902 
    result = getBestDealsCatalogIds_result()
5903 
    try:
5904 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5905 
    except CatalogServiceException, cex:
5906 
      result.cex = cex
5907 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
5908 
    result.write(oprot)
5909 
    oprot.writeMessageEnd()
5910 
    oprot.trans.flush()
5911 
 
5912 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
5913 
    args = getBestDealsCount_args()
5914 
    args.read(iprot)
5915 
    iprot.readMessageEnd()
5916 
    result = getBestDealsCount_result()
5917 
    try:
5918 
      result.success = self._handler.getBestDealsCount()
5919 
    except CatalogServiceException, cex:
5920 
      result.cex = cex
5921 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
5922 
    result.write(oprot)
5923 
    oprot.writeMessageEnd()
5924 
    oprot.trans.flush()
5925 
 
5926 
  def process_getComingSoon(self, seqid, iprot, oprot):
5927 
    args = getComingSoon_args()
5928 
    args.read(iprot)
5929 
    iprot.readMessageEnd()
5930 
    result = getComingSoon_result()
5931 
    try:
5932 
      result.success = self._handler.getComingSoon()
5933 
    except CatalogServiceException, isex:
5934 
      result.isex = isex
5935 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
5936 
    result.write(oprot)
5937 
    oprot.writeMessageEnd()
5938 
    oprot.trans.flush()
5939 
 
5940 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
5941 
    args = getComingSoonCatalogIds_args()
5942 
    args.read(iprot)
5943 
    iprot.readMessageEnd()
5944 
    result = getComingSoonCatalogIds_result()
5945 
    try:
5946 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5947 
    except CatalogServiceException, cex:
5948 
      result.cex = cex
5949 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
5950 
    result.write(oprot)
5951 
    oprot.writeMessageEnd()
5952 
    oprot.trans.flush()
5953 
 
5954 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
5955 
    args = getComingSoonCount_args()
5956 
    args.read(iprot)
5957 
    iprot.readMessageEnd()
5958 
    result = getComingSoonCount_result()
5959 
    try:
5960 
      result.success = self._handler.getComingSoonCount()
5961 
    except CatalogServiceException, cex:
5962 
      result.cex = cex
5963 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
5964 
    result.write(oprot)
5965 
    oprot.writeMessageEnd()
5966 
    oprot.trans.flush()
5967 
 
5968 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
5969 
    args = getLatestArrivals_args()
5970 
    args.read(iprot)
5971 
    iprot.readMessageEnd()
5972 
    result = getLatestArrivals_result()
5973 
    try:
5974 
      result.success = self._handler.getLatestArrivals()
5975 
    except CatalogServiceException, isex:
5976 
      result.isex = isex
5977 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
5978 
    result.write(oprot)
5979 
    oprot.writeMessageEnd()
5980 
    oprot.trans.flush()
5981 
 
5982 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
5983 
    args = getLatestArrivalsCatalogIds_args()
5984 
    args.read(iprot)
5985 
    iprot.readMessageEnd()
5986 
    result = getLatestArrivalsCatalogIds_result()
5987 
    try:
5988 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
5989 
    except CatalogServiceException, cex:
5990 
      result.cex = cex
5991 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5992 
    result.write(oprot)
5993 
    oprot.writeMessageEnd()
5994 
    oprot.trans.flush()
5995 
 
5996 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5997 
    args = getLatestArrivalsCount_args()
5998 
    args.read(iprot)
5999 
    iprot.readMessageEnd()
6000 
    result = getLatestArrivalsCount_result()
6001 
    try:
6002 
      result.success = self._handler.getLatestArrivalsCount()
6003 
    except CatalogServiceException, cex:
6004 
      result.cex = cex
6005 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
6006 
    result.write(oprot)
6007 
    oprot.writeMessageEnd()
6008 
    oprot.trans.flush()
6009 
 
6010 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
6011 
    args = generateNewEntityID_args()
6012 
    args.read(iprot)
6013 
    iprot.readMessageEnd()
6014 
    result = generateNewEntityID_result()
6015 
    result.success = self._handler.generateNewEntityID()
6016 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
6017 
    result.write(oprot)
6018 
    oprot.writeMessageEnd()
6019 
    oprot.trans.flush()
6020 
 
6021 
  def process_addCategory(self, seqid, iprot, oprot):
6022 
    args = addCategory_args()
6023 
    args.read(iprot)
6024 
    iprot.readMessageEnd()
6025 
    result = addCategory_result()
6026 
    result.success = self._handler.addCategory(args.category)
6027 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
6028 
    result.write(oprot)
6029 
    oprot.writeMessageEnd()
6030 
    oprot.trans.flush()
6031 
 
6032 
  def process_getCategory(self, seqid, iprot, oprot):
6033 
    args = getCategory_args()
6034 
    args.read(iprot)
6035 
    iprot.readMessageEnd()
6036 
    result = getCategory_result()
6037 
    result.success = self._handler.getCategory(args.id)
6038 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
6039 
    result.write(oprot)
6040 
    oprot.writeMessageEnd()
6041 
    oprot.trans.flush()
6042 
 
6043 
  def process_getAllCategories(self, seqid, iprot, oprot):
6044 
    args = getAllCategories_args()
6045 
    args.read(iprot)
6046 
    iprot.readMessageEnd()
6047 
    result = getAllCategories_result()
6048 
    result.success = self._handler.getAllCategories()
6049 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
6050 
    result.write(oprot)
6051 
    oprot.writeMessageEnd()
6052 
    oprot.trans.flush()
6053 
 
6054 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
6055 
    args = getAllSimilarItems_args()
6056 
    args.read(iprot)
6057 
    iprot.readMessageEnd()
6058 
    result = getAllSimilarItems_result()
6059 
    result.success = self._handler.getAllSimilarItems(args.itemId)
6060 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
6061 
    result.write(oprot)
6062 
    oprot.writeMessageEnd()
6063 
    oprot.trans.flush()
6064 
 
6065 
  def process_addSimilarItem(self, seqid, iprot, oprot):
6066 
    args = addSimilarItem_args()
6067 
    args.read(iprot)
6068 
    iprot.readMessageEnd()
6069 
    result = addSimilarItem_result()
6070 
    try:
6071 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
6072 
    except CatalogServiceException, cex:
6073 
      result.cex = cex
6074 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
6075 
    result.write(oprot)
6076 
    oprot.writeMessageEnd()
6077 
    oprot.trans.flush()
6078 
 
6512 kshitij.so 6079 
  def process_addTag(self, seqid, iprot, oprot):
6080 
    args = addTag_args()
6081 
    args.read(iprot)
6082 
    iprot.readMessageEnd()
6083 
    result = addTag_result()
6084 
    result.success = self._handler.addTag(args.displayName, args.itemId)
6085 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
6086 
    result.write(oprot)
6087 
    oprot.writeMessageEnd()
6088 
    oprot.trans.flush()
6089 
 
6090 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
6091 
    args = deleteEntityTag_args()
6092 
    args.read(iprot)
6093 
    iprot.readMessageEnd()
6094 
    result = deleteEntityTag_result()
6095 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
6096 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
6097 
    result.write(oprot)
6098 
    oprot.writeMessageEnd()
6099 
    oprot.trans.flush()
6100 
 
6101 
  def process_deleteTag(self, seqid, iprot, oprot):
6102 
    args = deleteTag_args()
6103 
    args.read(iprot)
6104 
    iprot.readMessageEnd()
6105 
    result = deleteTag_result()
6106 
    result.success = self._handler.deleteTag(args.displayName)
6107 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
6108 
    result.write(oprot)
6109 
    oprot.writeMessageEnd()
6110 
    oprot.trans.flush()
6111 
 
6112 
  def process_getAllTags(self, seqid, iprot, oprot):
6113 
    args = getAllTags_args()
6114 
    args.read(iprot)
6115 
    iprot.readMessageEnd()
6116 
    result = getAllTags_result()
6117 
    result.success = self._handler.getAllTags()
6118 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
6119 
    result.write(oprot)
6120 
    oprot.writeMessageEnd()
6121 
    oprot.trans.flush()
6122 
 
6123 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
6124 
    args = getAllEntitiesByTagName_args()
6125 
    args.read(iprot)
6126 
    iprot.readMessageEnd()
6127 
    result = getAllEntitiesByTagName_result()
6128 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
6129 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
6130 
    result.write(oprot)
6131 
    oprot.writeMessageEnd()
6132 
    oprot.trans.flush()
6133 
 
6845 amit.gupta 6134 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
6135 
    args = getAllEntityTags_args()
6136 
    args.read(iprot)
6137 
    iprot.readMessageEnd()
6138 
    result = getAllEntityTags_result()
6139 
    result.success = self._handler.getAllEntityTags()
6140 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
6141 
    result.write(oprot)
6142 
    oprot.writeMessageEnd()
6143 
    oprot.trans.flush()
6144 
 
6850 kshitij.so 6145 
  def process_addBanner(self, seqid, iprot, oprot):
6146 
    args = addBanner_args()
6147 
    args.read(iprot)
6148 
    iprot.readMessageEnd()
6149 
    result = addBanner_result()
8590 kshitij.so 6150 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 6151 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
6152 
    result.write(oprot)
6153 
    oprot.writeMessageEnd()
6154 
    oprot.trans.flush()
6155 
 
8579 kshitij.so 6156 
  def process_updateBanner(self, seqid, iprot, oprot):
6157 
    args = updateBanner_args()
6158 
    args.read(iprot)
6159 
    iprot.readMessageEnd()
6160 
    result = updateBanner_result()
6161 
    result.success = self._handler.updateBanner(args.banner)
6162 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
6163 
    result.write(oprot)
6164 
    oprot.writeMessageEnd()
6165 
    oprot.trans.flush()
6166 
 
6850 kshitij.so 6167 
  def process_getAllBanners(self, seqid, iprot, oprot):
6168 
    args = getAllBanners_args()
6169 
    args.read(iprot)
6170 
    iprot.readMessageEnd()
6171 
    result = getAllBanners_result()
6172 
    result.success = self._handler.getAllBanners()
6173 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
6174 
    result.write(oprot)
6175 
    oprot.writeMessageEnd()
6176 
    oprot.trans.flush()
6177 
 
6178 
  def process_deleteBanner(self, seqid, iprot, oprot):
6179 
    args = deleteBanner_args()
6180 
    args.read(iprot)
6181 
    iprot.readMessageEnd()
6182 
    result = deleteBanner_result()
9155 kshitij.so 6183 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 6184 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
6185 
    result.write(oprot)
6186 
    oprot.writeMessageEnd()
6187 
    oprot.trans.flush()
6188 
 
6189 
  def process_getBannerDetails(self, seqid, iprot, oprot):
6190 
    args = getBannerDetails_args()
6191 
    args.read(iprot)
6192 
    iprot.readMessageEnd()
6193 
    result = getBannerDetails_result()
9155 kshitij.so 6194 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 6195 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
6196 
    result.write(oprot)
6197 
    oprot.writeMessageEnd()
6198 
    oprot.trans.flush()
6199 
 
6200 
  def process_getActiveBanners(self, seqid, iprot, oprot):
6201 
    args = getActiveBanners_args()
6202 
    args.read(iprot)
6203 
    iprot.readMessageEnd()
6204 
    result = getActiveBanners_result()
6205 
    result.success = self._handler.getActiveBanners()
6206 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
6207 
    result.write(oprot)
6208 
    oprot.writeMessageEnd()
6209 
    oprot.trans.flush()
6210 
 
6849 kshitij.so 6211 
  def process_addBannerMap(self, seqid, iprot, oprot):
6212 
    args = addBannerMap_args()
6213 
    args.read(iprot)
6214 
    iprot.readMessageEnd()
6215 
    result = addBannerMap_result()
8579 kshitij.so 6216 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 6217 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
6218 
    result.write(oprot)
6219 
    oprot.writeMessageEnd()
6220 
    oprot.trans.flush()
6221 
 
8579 kshitij.so 6222 
  def process_updateBannerMap(self, seqid, iprot, oprot):
6223 
    args = updateBannerMap_args()
6224 
    args.read(iprot)
6225 
    iprot.readMessageEnd()
6226 
    result = updateBannerMap_result()
6227 
    result.success = self._handler.updateBannerMap(args.bannerMap)
6228 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
6229 
    result.write(oprot)
6230 
    oprot.writeMessageEnd()
6231 
    oprot.trans.flush()
6232 
 
6849 kshitij.so 6233 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
6234 
    args = deleteBannerMap_args()
6235 
    args.read(iprot)
6236 
    iprot.readMessageEnd()
6237 
    result = deleteBannerMap_result()
6238 
    result.success = self._handler.deleteBannerMap(args.bannerName)
6239 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
6240 
    result.write(oprot)
6241 
    oprot.writeMessageEnd()
6242 
    oprot.trans.flush()
6243 
 
6244 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
6245 
    args = getBannerMapDetails_args()
6246 
    args.read(iprot)
6247 
    iprot.readMessageEnd()
6248 
    result = getBannerMapDetails_result()
9155 kshitij.so 6249 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 6250 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
6251 
    result.write(oprot)
6252 
    oprot.writeMessageEnd()
6253 
    oprot.trans.flush()
6254 
 
8579 kshitij.so 6255 
  def process_addBannerUri(self, seqid, iprot, oprot):
6256 
    args = addBannerUri_args()
6257 
    args.read(iprot)
6258 
    iprot.readMessageEnd()
6259 
    result = addBannerUri_result()
6260 
    self._handler.addBannerUri(args.bannerUriMappings)
6261 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
6262 
    result.write(oprot)
6263 
    oprot.writeMessageEnd()
6264 
    oprot.trans.flush()
6265 
 
6266 
  def process_getUriMapping(self, seqid, iprot, oprot):
6267 
    args = getUriMapping_args()
6268 
    args.read(iprot)
6269 
    iprot.readMessageEnd()
6270 
    result = getUriMapping_result()
9155 kshitij.so 6271 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 6272 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
6273 
    result.write(oprot)
6274 
    oprot.writeMessageEnd()
6275 
    oprot.trans.flush()
6276 
 
6277 
  def process_addCampaign(self, seqid, iprot, oprot):
6278 
    args = addCampaign_args()
6279 
    args.read(iprot)
6280 
    iprot.readMessageEnd()
6281 
    result = addCampaign_result()
6282 
    self._handler.addCampaign(args.campaign)
6283 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
6284 
    result.write(oprot)
6285 
    oprot.writeMessageEnd()
6286 
    oprot.trans.flush()
6287 
 
6288 
  def process_getCampaigns(self, seqid, iprot, oprot):
6289 
    args = getCampaigns_args()
6290 
    args.read(iprot)
6291 
    iprot.readMessageEnd()
6292 
    result = getCampaigns_result()
6293 
    result.success = self._handler.getCampaigns(args.campaignName)
6294 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
6295 
    result.write(oprot)
6296 
    oprot.writeMessageEnd()
6297 
    oprot.trans.flush()
6298 
 
6299 
  def process_deleteCampaign(self, seqid, iprot, oprot):
6300 
    args = deleteCampaign_args()
6301 
    args.read(iprot)
6302 
    iprot.readMessageEnd()
6303 
    result = deleteCampaign_result()
6304 
    self._handler.deleteCampaign(args.campaignId)
6305 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
6306 
    result.write(oprot)
6307 
    oprot.writeMessageEnd()
6308 
    oprot.trans.flush()
6309 
 
6310 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
6311 
    args = getAllCampaigns_args()
6312 
    args.read(iprot)
6313 
    iprot.readMessageEnd()
6314 
    result = getAllCampaigns_result()
6315 
    result.success = self._handler.getAllCampaigns()
6316 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
6317 
    result.write(oprot)
6318 
    oprot.writeMessageEnd()
6319 
    oprot.trans.flush()
6320 
 
9155 kshitij.so 6321 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
6322 
    args = getActiveBannersForMobileSite_args()
6323 
    args.read(iprot)
6324 
    iprot.readMessageEnd()
6325 
    result = getActiveBannersForMobileSite_result()
6326 
    result.success = self._handler.getActiveBannersForMobileSite()
6327 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
6328 
    result.write(oprot)
6329 
    oprot.writeMessageEnd()
6330 
    oprot.trans.flush()
6331 
 
5944 mandeep.dh 6332 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
6333 
    args = deleteSimilarItem_args()
6334 
    args.read(iprot)
6335 
    iprot.readMessageEnd()
6336 
    result = deleteSimilarItem_result()
6337 
    try:
6338 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
6339 
    except CatalogServiceException, cex:
6340 
      result.cex = cex
6341 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
6342 
    result.write(oprot)
6343 
    oprot.writeMessageEnd()
6344 
    oprot.trans.flush()
6345 
 
6346 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
6347 
    args = checkSimilarItem_args()
6348 
    args.read(iprot)
6349 
    iprot.readMessageEnd()
6350 
    result = checkSimilarItem_result()
6351 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
6352 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
6353 
    result.write(oprot)
6354 
    oprot.writeMessageEnd()
6355 
    oprot.trans.flush()
6356 
 
6357 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
6358 
    args = validateRiskyStatus_args()
6359 
    args.read(iprot)
6360 
    iprot.readMessageEnd()
6361 
    result = validateRiskyStatus_result()
6362 
    self._handler.validateRiskyStatus(args.itemId)
6363 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
6364 
    result.write(oprot)
6365 
    oprot.writeMessageEnd()
6366 
    oprot.trans.flush()
6367 
 
6368 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
6369 
    args = changeItemRiskyFlag_args()
6370 
    args.read(iprot)
6371 
    iprot.readMessageEnd()
6372 
    result = changeItemRiskyFlag_result()
6373 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
6374 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
6375 
    result.write(oprot)
6376 
    oprot.writeMessageEnd()
6377 
    oprot.trans.flush()
6378 
 
6379 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
6380 
    args = getItemsByRiskyFlag_args()
6381 
    args.read(iprot)
6382 
    iprot.readMessageEnd()
6383 
    result = getItemsByRiskyFlag_result()
6384 
    result.success = self._handler.getItemsByRiskyFlag()
6385 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
6386 
    result.write(oprot)
6387 
    oprot.writeMessageEnd()
6388 
    oprot.trans.flush()
6389 
 
6390 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
6391 
    args = getItemsForMasterSheet_args()
6392 
    args.read(iprot)
6393 
    iprot.readMessageEnd()
6394 
    result = getItemsForMasterSheet_result()
6395 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
6396 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
6397 
    result.write(oprot)
6398 
    oprot.writeMessageEnd()
6399 
    oprot.trans.flush()
6400 
 
6401 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
6402 
    args = getSimilarItemsCatalogIds_args()
6403 
    args.read(iprot)
6404 
    iprot.readMessageEnd()
6405 
    result = getSimilarItemsCatalogIds_result()
6406 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
6407 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
6408 
    result.write(oprot)
6409 
    oprot.writeMessageEnd()
6410 
    oprot.trans.flush()
6411 
 
6412 
  def process_addProductNotification(self, seqid, iprot, oprot):
6413 
    args = addProductNotification_args()
6414 
    args.read(iprot)
6415 
    iprot.readMessageEnd()
6416 
    result = addProductNotification_result()
6417 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
6418 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
6419 
    result.write(oprot)
6420 
    oprot.writeMessageEnd()
6421 
    oprot.trans.flush()
6422 
 
6423 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
6424 
    args = sendProductNotifications_args()
6425 
    args.read(iprot)
6426 
    iprot.readMessageEnd()
6427 
    result = sendProductNotifications_result()
6428 
    result.success = self._handler.sendProductNotifications()
6429 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
6430 
    result.write(oprot)
6431 
    oprot.writeMessageEnd()
6432 
    oprot.trans.flush()
6433 
 
6434 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
6435 
    args = getAllBrandsByCategory_args()
6436 
    args.read(iprot)
6437 
    iprot.readMessageEnd()
6438 
    result = getAllBrandsByCategory_result()
6439 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
6440 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
6441 
    result.write(oprot)
6442 
    oprot.writeMessageEnd()
6443 
    oprot.trans.flush()
6444 
 
6445 
  def process_getAllBrands(self, seqid, iprot, oprot):
6446 
    args = getAllBrands_args()
6447 
    args.read(iprot)
6448 
    iprot.readMessageEnd()
6449 
    result = getAllBrands_result()
6450 
    result.success = self._handler.getAllBrands()
6451 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
6452 
    result.write(oprot)
6453 
    oprot.writeMessageEnd()
6454 
    oprot.trans.flush()
6455 
 
6456 
  def process_getAllSources(self, seqid, iprot, oprot):
6457 
    args = getAllSources_args()
6458 
    args.read(iprot)
6459 
    iprot.readMessageEnd()
6460 
    result = getAllSources_result()
6461 
    result.success = self._handler.getAllSources()
6462 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
6463 
    result.write(oprot)
6464 
    oprot.writeMessageEnd()
6465 
    oprot.trans.flush()
6466 
 
6467 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
6468 
    args = getItemPricingBySource_args()
6469 
    args.read(iprot)
6470 
    iprot.readMessageEnd()
6471 
    result = getItemPricingBySource_result()
6472 
    try:
6473 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
6474 
    except CatalogServiceException, cex:
6475 
      result.cex = cex
6476 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
6477 
    result.write(oprot)
6478 
    oprot.writeMessageEnd()
6479 
    oprot.trans.flush()
6480 
 
6481 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
6482 
    args = addSourceItemPricing_args()
6483 
    args.read(iprot)
6484 
    iprot.readMessageEnd()
6485 
    result = addSourceItemPricing_result()
6486 
    try:
6487 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
6488 
    except CatalogServiceException, cex:
6489 
      result.cex = cex
6490 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
6491 
    result.write(oprot)
6492 
    oprot.writeMessageEnd()
6493 
    oprot.trans.flush()
6494 
 
6495 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
6496 
    args = getAllSourcePricing_args()
6497 
    args.read(iprot)
6498 
    iprot.readMessageEnd()
6499 
    result = getAllSourcePricing_result()
6500 
    try:
6501 
      result.success = self._handler.getAllSourcePricing(args.itemId)
6502 
    except CatalogServiceException, cex:
6503 
      result.cex = cex
6504 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
6505 
    result.write(oprot)
6506 
    oprot.writeMessageEnd()
6507 
    oprot.trans.flush()
6508 
 
6509 
  def process_getItemForSource(self, seqid, iprot, oprot):
6510 
    args = getItemForSource_args()
6511 
    args.read(iprot)
6512 
    iprot.readMessageEnd()
6513 
    result = getItemForSource_result()
6514 
    try:
6515 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
6516 
    except CatalogServiceException, cex:
6517 
      result.cex = cex
6518 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
6519 
    result.write(oprot)
6520 
    oprot.writeMessageEnd()
6521 
    oprot.trans.flush()
6522 
 
6523 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
6524 
    args = searchItemsInRange_args()
6525 
    args.read(iprot)
6526 
    iprot.readMessageEnd()
6527 
    result = searchItemsInRange_result()
6528 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
6529 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
6530 
    result.write(oprot)
6531 
    oprot.writeMessageEnd()
6532 
    oprot.trans.flush()
6533 
 
6534 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
6535 
    args = getSearchResultCount_args()
6536 
    args.read(iprot)
6537 
    iprot.readMessageEnd()
6538 
    result = getSearchResultCount_result()
6539 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
6540 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
6541 
    result.write(oprot)
6542 
    oprot.writeMessageEnd()
6543 
    oprot.trans.flush()
6544 
 
6545 
  def process_getProductNotifications(self, seqid, iprot, oprot):
6546 
    args = getProductNotifications_args()
6547 
    args.read(iprot)
6548 
    iprot.readMessageEnd()
6549 
    result = getProductNotifications_result()
6550 
    result.success = self._handler.getProductNotifications(args.startDateTime)
6551 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
6552 
    result.write(oprot)
6553 
    oprot.writeMessageEnd()
6554 
    oprot.trans.flush()
6555 
 
6556 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
6557 
    args = getProductNotificationRequestCount_args()
6558 
    args.read(iprot)
6559 
    iprot.readMessageEnd()
6560 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 6561 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 6562 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
6563 
    result.write(oprot)
6564 
    oprot.writeMessageEnd()
6565 
    oprot.trans.flush()
6566 
 
6567 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
6568 
    args = addAuthorizationLog_args()
6569 
    args.read(iprot)
6570 
    iprot.readMessageEnd()
6571 
    result = addAuthorizationLog_result()
6572 
    try:
6573 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
6574 
    except CatalogServiceException, cex:
6575 
      result.cex = cex
6576 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
6577 
    result.write(oprot)
6578 
    oprot.writeMessageEnd()
6579 
    oprot.trans.flush()
6580 
 
6581 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
6582 
    args = addupdateVoucherForItem_args()
6583 
    args.read(iprot)
6584 
    iprot.readMessageEnd()
6585 
    result = addupdateVoucherForItem_result()
6586 
    try:
6587 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
6588 
    except CatalogServiceException, cex:
6589 
      result.cex = cex
6590 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
6591 
    result.write(oprot)
6592 
    oprot.writeMessageEnd()
6593 
    oprot.trans.flush()
6594 
 
6595 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
6596 
    args = deleteVoucherForItem_args()
6597 
    args.read(iprot)
6598 
    iprot.readMessageEnd()
6599 
    result = deleteVoucherForItem_result()
6600 
    try:
6601 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
6602 
    except CatalogServiceException, cex:
6603 
      result.cex = cex
6604 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
6605 
    result.write(oprot)
6606 
    oprot.writeMessageEnd()
6607 
    oprot.trans.flush()
6608 
 
6609 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
6610 
    args = getVoucherAmount_args()
6611 
    args.read(iprot)
6612 
    iprot.readMessageEnd()
6613 
    result = getVoucherAmount_result()
6614 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
6615 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
6616 
    result.write(oprot)
6617 
    oprot.writeMessageEnd()
6618 
    oprot.trans.flush()
6619 
 
6620 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
6621 
    args = getAllItemVouchers_args()
6622 
    args.read(iprot)
6623 
    iprot.readMessageEnd()
6624 
    result = getAllItemVouchers_result()
6625 
    result.success = self._handler.getAllItemVouchers(args.itemId)
6626 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
6627 
    result.write(oprot)
6628 
    oprot.writeMessageEnd()
6629 
    oprot.trans.flush()
6630 
 
6631 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
6632 
    args = isValidCatalogItemId_args()
6633 
    args.read(iprot)
6634 
    iprot.readMessageEnd()
6635 
    result = isValidCatalogItemId_result()
6636 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
6637 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
6638 
    result.write(oprot)
6639 
    oprot.writeMessageEnd()
6640 
    oprot.trans.flush()
6641 
 
6039 amit.gupta 6642 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
6643 
    args = getVatPercentageForItem_args()
6644 
    args.read(iprot)
6645 
    iprot.readMessageEnd()
6646 
    result = getVatPercentageForItem_result()
7340 amit.gupta 6647 
    try:
6648 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
6649 
    except CatalogServiceException, cex:
6650 
      result.cex = cex
6039 amit.gupta 6651 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
6652 
    result.write(oprot)
6653 
    oprot.writeMessageEnd()
6654 
    oprot.trans.flush()
5944 mandeep.dh 6655 
 
6039 amit.gupta 6656 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
6657 
    args = getVatAmountForItem_args()
6658 
    args.read(iprot)
6659 
    iprot.readMessageEnd()
6660 
    result = getVatAmountForItem_result()
6661 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
6662 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
6663 
    result.write(oprot)
6664 
    oprot.writeMessageEnd()
6665 
    oprot.trans.flush()
6666 
 
6531 vikram.rag 6667 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
6668 
    args = getAllIgnoredInventoryUpdateItemsList_args()
6669 
    args.read(iprot)
6670 
    iprot.readMessageEnd()
6671 
    result = getAllIgnoredInventoryUpdateItemsList_result()
6672 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
6673 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
6674 
    result.write(oprot)
6675 
    oprot.writeMessageEnd()
6676 
    oprot.trans.flush()
6039 amit.gupta 6677 
 
6821 amar.kumar 6678 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
6679 
    args = getAllAliveItems_args()
6680 
    args.read(iprot)
6681 
    iprot.readMessageEnd()
6682 
    result = getAllAliveItems_result()
6683 
    result.success = self._handler.getAllAliveItems()
6684 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
6685 
    result.write(oprot)
6686 
    oprot.writeMessageEnd()
6687 
    oprot.trans.flush()
6688 
 
6805 anupam.sin 6689 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
6690 
    args = getInsuranceAmount_args()
6691 
    args.read(iprot)
6692 
    iprot.readMessageEnd()
6693 
    result = getInsuranceAmount_result()
6921 anupam.sin 6694 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 6695 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
6696 
    result.write(oprot)
6697 
    oprot.writeMessageEnd()
6698 
    oprot.trans.flush()
6531 vikram.rag 6699 
 
6805 anupam.sin 6700 
  def process_getInsurer(self, seqid, iprot, oprot):
6701 
    args = getInsurer_args()
6702 
    args.read(iprot)
6703 
    iprot.readMessageEnd()
6704 
    result = getInsurer_result()
6705 
    result.success = self._handler.getInsurer(args.insurerId)
6706 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
6707 
    result.write(oprot)
6708 
    oprot.writeMessageEnd()
6709 
    oprot.trans.flush()
6710 
 
6838 vikram.rag 6711 
  def process_getAllInsurers(self, seqid, iprot, oprot):
6712 
    args = getAllInsurers_args()
6713 
    args.read(iprot)
6714 
    iprot.readMessageEnd()
6715 
    result = getAllInsurers_result()
6716 
    result.success = self._handler.getAllInsurers()
6717 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
6718 
    result.write(oprot)
6719 
    oprot.writeMessageEnd()
6720 
    oprot.trans.flush()
6805 anupam.sin 6721 
 
6962 rajveer 6722 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
6723 
    args = updateInsuranceDeclaredAmount_args()
6724 
    args.read(iprot)
6725 
    iprot.readMessageEnd()
6726 
    result = updateInsuranceDeclaredAmount_result()
6727 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
6728 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
6729 
    result.write(oprot)
6730 
    oprot.writeMessageEnd()
6731 
    oprot.trans.flush()
6838 vikram.rag 6732 
 
7190 amar.kumar 6733 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
6734 
    args = getFreebieForItem_args()
6735 
    args.read(iprot)
6736 
    iprot.readMessageEnd()
6737 
    result = getFreebieForItem_result()
6738 
    result.success = self._handler.getFreebieForItem(args.itemId)
6739 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
6740 
    result.write(oprot)
6741 
    oprot.writeMessageEnd()
6742 
    oprot.trans.flush()
6962 rajveer 6743 
 
7190 amar.kumar 6744 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
6745 
    args = addOrUpdateFreebieForItem_args()
6746 
    args.read(iprot)
6747 
    iprot.readMessageEnd()
6748 
    result = addOrUpdateFreebieForItem_result()
6749 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
6750 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
6751 
    result.write(oprot)
6752 
    oprot.writeMessageEnd()
6753 
    oprot.trans.flush()
6754 
 
7272 amit.gupta 6755 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
6756 
    args = addOrUpdateBrandInfo_args()
6757 
    args.read(iprot)
6758 
    iprot.readMessageEnd()
6759 
    result = addOrUpdateBrandInfo_result()
6760 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
6761 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
6762 
    result.write(oprot)
6763 
    oprot.writeMessageEnd()
6764 
    oprot.trans.flush()
6765 
 
6766 
  def process_getBrandInfo(self, seqid, iprot, oprot):
6767 
    args = getBrandInfo_args()
6768 
    args.read(iprot)
6769 
    iprot.readMessageEnd()
6770 
    result = getBrandInfo_result()
6771 
    result.success = self._handler.getBrandInfo()
6772 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
6773 
    result.write(oprot)
6774 
    oprot.writeMessageEnd()
6775 
    oprot.trans.flush()
6776 
 
7256 rajveer 6777 
  def process_getStorePricing(self, seqid, iprot, oprot):
6778 
    args = getStorePricing_args()
6779 
    args.read(iprot)
6780 
    iprot.readMessageEnd()
6781 
    result = getStorePricing_result()
6782 
    result.success = self._handler.getStorePricing(args.itemId)
6783 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
6784 
    result.write(oprot)
6785 
    oprot.writeMessageEnd()
6786 
    oprot.trans.flush()
7190 amar.kumar 6787 
 
7306 rajveer 6788 
  def process_getStorePricings(self, seqid, iprot, oprot):
6789 
    args = getStorePricings_args()
6790 
    args.read(iprot)
6791 
    iprot.readMessageEnd()
6792 
    result = getStorePricings_result()
6793 
    result.success = self._handler.getStorePricings(args.itemIds)
6794 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
6795 
    result.write(oprot)
6796 
    oprot.writeMessageEnd()
6797 
    oprot.trans.flush()
6798 
 
7265 rajveer 6799 
  def process_updateStorePricing(self, seqid, iprot, oprot):
6800 
    args = updateStorePricing_args()
6801 
    args.read(iprot)
6802 
    iprot.readMessageEnd()
6803 
    result = updateStorePricing_result()
7382 rajveer 6804 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 6805 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
6806 
    result.write(oprot)
6807 
    oprot.writeMessageEnd()
6808 
    oprot.trans.flush()
7256 rajveer 6809 
 
7281 kshitij.so 6810 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
6811 
    args = getAllAmazonListedItems_args()
6812 
    args.read(iprot)
6813 
    iprot.readMessageEnd()
6814 
    result = getAllAmazonListedItems_result()
6815 
    result.success = self._handler.getAllAmazonListedItems()
6816 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
6817 
    result.write(oprot)
6818 
    oprot.writeMessageEnd()
6819 
    oprot.trans.flush()
7265 rajveer 6820 
 
8619 kshitij.so 6821 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
6822 
    args = searchAmazonItems_args()
6823 
    args.read(iprot)
6824 
    iprot.readMessageEnd()
6825 
    result = searchAmazonItems_result()
6826 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
6827 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
6828 
    result.write(oprot)
6829 
    oprot.writeMessageEnd()
6830 
    oprot.trans.flush()
6831 
 
6832 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
6833 
    args = getAmazonSearchResultCount_args()
6834 
    args.read(iprot)
6835 
    iprot.readMessageEnd()
6836 
    result = getAmazonSearchResultCount_result()
6837 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
6838 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
6839 
    result.write(oprot)
6840 
    oprot.writeMessageEnd()
6841 
    oprot.trans.flush()
6842 
 
6843 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
6844 
    args = getCountForAmazonlistedItems_args()
6845 
    args.read(iprot)
6846 
    iprot.readMessageEnd()
6847 
    result = getCountForAmazonlistedItems_result()
6848 
    result.success = self._handler.getCountForAmazonlistedItems()
6849 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
6850 
    result.write(oprot)
6851 
    oprot.writeMessageEnd()
6852 
    oprot.trans.flush()
6853 
 
7281 kshitij.so 6854 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
6855 
    args = getAmazonItemDetails_args()
6856 
    args.read(iprot)
6857 
    iprot.readMessageEnd()
6858 
    result = getAmazonItemDetails_result()
6859 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
6860 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
6861 
    result.write(oprot)
6862 
    oprot.writeMessageEnd()
6863 
    oprot.trans.flush()
6864 
 
6865 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
6866 
    args = updateAmazonItemDetails_args()
6867 
    args.read(iprot)
6868 
    iprot.readMessageEnd()
6869 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 6870 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 6871 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
6872 
    result.write(oprot)
6873 
    oprot.writeMessageEnd()
6874 
    oprot.trans.flush()
6875 
 
6876 
  def process_addAmazonItem(self, seqid, iprot, oprot):
6877 
    args = addAmazonItem_args()
6878 
    args.read(iprot)
6879 
    iprot.readMessageEnd()
6880 
    result = addAmazonItem_result()
6881 
    self._handler.addAmazonItem(args.amazonlisted)
6882 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
6883 
    result.write(oprot)
6884 
    oprot.writeMessageEnd()
6885 
    oprot.trans.flush()
6886 
 
7291 vikram.rag 6887 
  def process_getAsinItems(self, seqid, iprot, oprot):
6888 
    args = getAsinItems_args()
6889 
    args.read(iprot)
6890 
    iprot.readMessageEnd()
6891 
    result = getAsinItems_result()
6892 
    result.success = self._handler.getAsinItems()
6893 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
6894 
    result.write(oprot)
6895 
    oprot.writeMessageEnd()
6896 
    oprot.trans.flush()
7281 kshitij.so 6897 
 
7291 vikram.rag 6898 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
6899 
    args = getAllFbaListedItems_args()
6900 
    args.read(iprot)
6901 
    iprot.readMessageEnd()
6902 
    result = getAllFbaListedItems_result()
6903 
    result.success = self._handler.getAllFbaListedItems()
6904 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
6905 
    result.write(oprot)
6906 
    oprot.writeMessageEnd()
6907 
    oprot.trans.flush()
6908 
 
6909 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
6910 
    args = getAllNonFbaListedItems_args()
6911 
    args.read(iprot)
6912 
    iprot.readMessageEnd()
6913 
    result = getAllNonFbaListedItems_result()
6914 
    result.success = self._handler.getAllNonFbaListedItems()
6915 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
6916 
    result.write(oprot)
6917 
    oprot.writeMessageEnd()
6918 
    oprot.trans.flush()
6919 
 
7460 kshitij.so 6920 
  def process_updateItemInventory(self, seqid, iprot, oprot):
6921 
    args = updateItemInventory_args()
6922 
    args.read(iprot)
6923 
    iprot.readMessageEnd()
6924 
    result = updateItemInventory_result()
6925 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
6926 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
6927 
    result.write(oprot)
6928 
    oprot.writeMessageEnd()
6929 
    oprot.trans.flush()
7291 vikram.rag 6930 
 
7770 kshitij.so 6931 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
6932 
    args = updateTimestampForAmazonFeeds_args()
6933 
    args.read(iprot)
6934 
    iprot.readMessageEnd()
6935 
    result = updateTimestampForAmazonFeeds_result()
6936 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
6937 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
6938 
    result.write(oprot)
6939 
    oprot.writeMessageEnd()
6940 
    oprot.trans.flush()
7460 kshitij.so 6941 
 
7897 amar.kumar 6942 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
6943 
    args = getAllParentCategories_args()
6944 
    args.read(iprot)
6945 
    iprot.readMessageEnd()
6946 
    result = getAllParentCategories_result()
6947 
    result.success = self._handler.getAllParentCategories()
6948 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
6949 
    result.write(oprot)
6950 
    oprot.writeMessageEnd()
6951 
    oprot.trans.flush()
7770 kshitij.so 6952 
 
7977 kshitij.so 6953 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
6954 
    args = addPageViewEvent_args()
6955 
    args.read(iprot)
6956 
    iprot.readMessageEnd()
6957 
    result = addPageViewEvent_result()
6958 
    self._handler.addPageViewEvent(args.pageViewEvents)
6959 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
6960 
    result.write(oprot)
6961 
    oprot.writeMessageEnd()
6962 
    oprot.trans.flush()
7897 amar.kumar 6963 
 
7977 kshitij.so 6964 
  def process_addCartEvent(self, seqid, iprot, oprot):
6965 
    args = addCartEvent_args()
6966 
    args.read(iprot)
6967 
    iprot.readMessageEnd()
6968 
    result = addCartEvent_result()
6969 
    self._handler.addCartEvent(args.cartEvents)
6970 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
6971 
    result.write(oprot)
6972 
    oprot.writeMessageEnd()
6973 
    oprot.trans.flush()
6974 
 
8182 amar.kumar 6975 
  def process_addEbayItem(self, seqid, iprot, oprot):
6976 
    args = addEbayItem_args()
6977 
    args.read(iprot)
6978 
    iprot.readMessageEnd()
6979 
    result = addEbayItem_result()
6980 
    self._handler.addEbayItem(args.ebayItem)
6981 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
6982 
    result.write(oprot)
6983 
    oprot.writeMessageEnd()
6984 
    oprot.trans.flush()
6985 
 
6986 
  def process_getEbayItem(self, seqid, iprot, oprot):
6987 
    args = getEbayItem_args()
6988 
    args.read(iprot)
6989 
    iprot.readMessageEnd()
6990 
    result = getEbayItem_result()
6991 
    result.success = self._handler.getEbayItem(args.listingId)
6992 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
6993 
    result.write(oprot)
6994 
    oprot.writeMessageEnd()
6995 
    oprot.trans.flush()
6996 
 
6997 
  def process_updateEbayItem(self, seqid, iprot, oprot):
6998 
    args = updateEbayItem_args()
6999 
    args.read(iprot)
7000 
    iprot.readMessageEnd()
7001 
    result = updateEbayItem_result()
7002 
    self._handler.updateEbayItem(args.ebayItem)
7003 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
7004 
    result.write(oprot)
7005 
    oprot.writeMessageEnd()
7006 
    oprot.trans.flush()
7007 
 
8139 kshitij.so 7008 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
7009 
    args = getAmazonListedItems_args()
7010 
    args.read(iprot)
7011 
    iprot.readMessageEnd()
7012 
    result = getAmazonListedItems_result()
7013 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
7014 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
7015 
    result.write(oprot)
7016 
    oprot.writeMessageEnd()
7017 
    oprot.trans.flush()
7977 kshitij.so 7018 
 
8168 kshitij.so 7019 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
7020 
    args = updateAmazonAttributesInBulk_args()
7021 
    args.read(iprot)
7022 
    iprot.readMessageEnd()
7023 
    result = updateAmazonAttributesInBulk_result()
7024 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
7025 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
7026 
    result.write(oprot)
7027 
    oprot.writeMessageEnd()
7028 
    oprot.trans.flush()
8139 kshitij.so 7029 
 
8379 vikram.rag 7030 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
7031 
    args = getAllItemstoListOnFba_args()
7032 
    args.read(iprot)
7033 
    iprot.readMessageEnd()
7034 
    result = getAllItemstoListOnFba_result()
7035 
    result.success = self._handler.getAllItemstoListOnFba()
7036 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
7037 
    result.write(oprot)
7038 
    oprot.writeMessageEnd()
7039 
    oprot.trans.flush()
8168 kshitij.so 7040 
 
8379 vikram.rag 7041 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
7042 
    args = getAllItemstoListOnNonFba_args()
7043 
    args.read(iprot)
7044 
    iprot.readMessageEnd()
7045 
    result = getAllItemstoListOnNonFba_result()
7046 
    result.success = self._handler.getAllItemstoListOnNonFba()
7047 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
7048 
    result.write(oprot)
7049 
    oprot.writeMessageEnd()
7050 
    oprot.trans.flush()
7051 
 
8619 kshitij.so 7052 
  def process_updateAsin(self, seqid, iprot, oprot):
7053 
    args = updateAsin_args()
7054 
    args.read(iprot)
7055 
    iprot.readMessageEnd()
7056 
    result = updateAsin_result()
7057 
    self._handler.updateAsin(args.item)
7058 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
7059 
    result.write(oprot)
7060 
    oprot.writeMessageEnd()
7061 
    oprot.trans.flush()
8616 vikram.rag 7062 
 
8739 vikram.rag 7063 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
7064 
    args = addOrUpdateSnapdealItem_args()
7065 
    args.read(iprot)
7066 
    iprot.readMessageEnd()
7067 
    result = addOrUpdateSnapdealItem_result()
7068 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
7069 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
7070 
    result.write(oprot)
7071 
    oprot.writeMessageEnd()
7072 
    oprot.trans.flush()
8619 kshitij.so 7073 
 
8739 vikram.rag 7074 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
7075 
    args = getSnapdealItem_args()
7076 
    args.read(iprot)
7077 
    iprot.readMessageEnd()
7078 
    result = getSnapdealItem_result()
7079 
    result.success = self._handler.getSnapdealItem(args.item_id)
7080 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
7081 
    result.write(oprot)
7082 
    oprot.writeMessageEnd()
7083 
    oprot.trans.flush()
7084 
 
9242 kshitij.so 7085 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
7086 
    args = getSnapdealItemDetails_args()
7087 
    args.read(iprot)
7088 
    iprot.readMessageEnd()
7089 
    result = getSnapdealItemDetails_result()
7090 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
7091 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
7092 
    result.write(oprot)
7093 
    oprot.writeMessageEnd()
7094 
    oprot.trans.flush()
7095 
 
8739 vikram.rag 7096 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
7097 
    args = getAllSnapdealItems_args()
7098 
    args.read(iprot)
7099 
    iprot.readMessageEnd()
7100 
    result = getAllSnapdealItems_result()
7101 
    result.success = self._handler.getAllSnapdealItems()
7102 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
7103 
    result.write(oprot)
7104 
    oprot.writeMessageEnd()
7105 
    oprot.trans.flush()
7106 
 
9242 kshitij.so 7107 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
7108 
    args = getSnapdealItems_args()
7109 
    args.read(iprot)
7110 
    iprot.readMessageEnd()
7111 
    result = getSnapdealItems_result()
7112 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
7113 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
7114 
    result.write(oprot)
7115 
    oprot.writeMessageEnd()
7116 
    oprot.trans.flush()
8739 vikram.rag 7117 
 
9242 kshitij.so 7118 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
7119 
    args = searchSnapdealItems_args()
7120 
    args.read(iprot)
7121 
    iprot.readMessageEnd()
7122 
    result = searchSnapdealItems_result()
7123 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
7124 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
7125 
    result.write(oprot)
7126 
    oprot.writeMessageEnd()
7127 
    oprot.trans.flush()
7128 
 
7129 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
7130 
    args = getCountForSnapdealItems_args()
7131 
    args.read(iprot)
7132 
    iprot.readMessageEnd()
7133 
    result = getCountForSnapdealItems_result()
7134 
    result.success = self._handler.getCountForSnapdealItems()
7135 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
7136 
    result.write(oprot)
7137 
    oprot.writeMessageEnd()
7138 
    oprot.trans.flush()
7139 
 
7140 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
7141 
    args = getSnapdealSearchResultCount_args()
7142 
    args.read(iprot)
7143 
    iprot.readMessageEnd()
7144 
    result = getSnapdealSearchResultCount_result()
7145 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
7146 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
7147 
    result.write(oprot)
7148 
    oprot.writeMessageEnd()
7149 
    oprot.trans.flush()
7150 
 
9299 kshitij.so 7151 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
7152 
    args = getPrefferedInsurerForItem_args()
7153 
    args.read(iprot)
7154 
    iprot.readMessageEnd()
7155 
    result = getPrefferedInsurerForItem_result()
7156 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
7157 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
7158 
    result.write(oprot)
7159 
    oprot.writeMessageEnd()
7160 
    oprot.trans.flush()
9242 kshitij.so 7161 
 
9456 vikram.rag 7162 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
7163 
    args = getSnapdealItembySkuAtSnapdeal_args()
7164 
    args.read(iprot)
7165 
    iprot.readMessageEnd()
7166 
    result = getSnapdealItembySkuAtSnapdeal_result()
7167 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
7168 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
7169 
    result.write(oprot)
7170 
    oprot.writeMessageEnd()
7171 
    oprot.trans.flush()
9299 kshitij.so 7172 
 
9621 manish.sha 7173 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
7174 
    args = getProductFeedSubmit_args()
7175 
    args.read(iprot)
7176 
    iprot.readMessageEnd()
7177 
    result = getProductFeedSubmit_result()
7178 
    try:
7179 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
7180 
    except CatalogServiceException, cex:
7181 
      result.cex = cex
7182 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
7183 
    result.write(oprot)
7184 
    oprot.writeMessageEnd()
7185 
    oprot.trans.flush()
9456 vikram.rag 7186 
 
9621 manish.sha 7187 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
7188 
    args = addProductFeedSubmit_args()
7189 
    args.read(iprot)
7190 
    iprot.readMessageEnd()
7191 
    result = addProductFeedSubmit_result()
7192 
    try:
7193 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
7194 
    except CatalogServiceException, cex:
7195 
      result.cex = cex
7196 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
7197 
    result.write(oprot)
7198 
    oprot.writeMessageEnd()
7199 
    oprot.trans.flush()
7200 
 
7201 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
7202 
    args = updateProductFeedSubmit_args()
7203 
    args.read(iprot)
7204 
    iprot.readMessageEnd()
7205 
    result = updateProductFeedSubmit_result()
7206 
    try:
7207 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
7208 
    except CatalogServiceException, cex:
7209 
      result.cex = cex
7210 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
7211 
    result.write(oprot)
7212 
    oprot.writeMessageEnd()
7213 
    oprot.trans.flush()
7214 
 
7215 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
7216 
    args = deleteProductFeedSubmit_args()
7217 
    args.read(iprot)
7218 
    iprot.readMessageEnd()
7219 
    result = deleteProductFeedSubmit_result()
7220 
    try:
7221 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
7222 
    except CatalogServiceException, cex:
7223 
      result.cex = cex
7224 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
7225 
    result.write(oprot)
7226 
    oprot.writeMessageEnd()
7227 
    oprot.trans.flush()
7228 
 
7229 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
7230 
    args = getAllProductFeedSubmit_args()
7231 
    args.read(iprot)
7232 
    iprot.readMessageEnd()
7233 
    result = getAllProductFeedSubmit_result()
7234 
    try:
7235 
      result.success = self._handler.getAllProductFeedSubmit()
7236 
    except CatalogServiceException, cex:
7237 
      result.cex = cex
7238 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
7239 
    result.write(oprot)
7240 
    oprot.writeMessageEnd()
7241 
    oprot.trans.flush()
7242 
 
9724 kshitij.so 7243 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
7244 
    args = getMarketplacedetailsForItem_args()
7245 
    args.read(iprot)
7246 
    iprot.readMessageEnd()
7247 
    result = getMarketplacedetailsForItem_result()
7248 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
7249 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
7250 
    result.write(oprot)
7251 
    oprot.writeMessageEnd()
7252 
    oprot.trans.flush()
9621 manish.sha 7253 
 
9724 kshitij.so 7254 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
7255 
    args = updateMarketplaceAttributesForItem_args()
7256 
    args.read(iprot)
7257 
    iprot.readMessageEnd()
7258 
    result = updateMarketplaceAttributesForItem_result()
7259 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
7260 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
7261 
    result.write(oprot)
7262 
    oprot.writeMessageEnd()
7263 
    oprot.trans.flush()
7264 
 
9779 kshitij.so 7265 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
7266 
    args = getCostingForMarketplace_args()
7267 
    args.read(iprot)
7268 
    iprot.readMessageEnd()
7269 
    result = getCostingForMarketplace_result()
7270 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
7271 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
7272 
    result.write(oprot)
7273 
    oprot.writeMessageEnd()
7274 
    oprot.trans.flush()
7275 
 
9776 vikram.rag 7276 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
7277 
    args = getMarketPlaceItemsForPriceUpdate_args()
7278 
    args.read(iprot)
7279 
    iprot.readMessageEnd()
7280 
    result = getMarketPlaceItemsForPriceUpdate_result()
7281 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
7282 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
7283 
    result.write(oprot)
7284 
    oprot.writeMessageEnd()
7285 
    oprot.trans.flush()
9724 kshitij.so 7286 
 
9776 vikram.rag 7287 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
7288 
    args = updateMarketPlacePriceUpdateStatus_args()
7289 
    args.read(iprot)
7290 
    iprot.readMessageEnd()
7291 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 7292 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 7293 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
7294 
    result.write(oprot)
7295 
    oprot.writeMessageEnd()
7296 
    oprot.trans.flush()
7297 
 
9861 rajveer 7298 
  def process_updateItemHoldInventory(self, seqid, iprot, oprot):
7299 
    args = updateItemHoldInventory_args()
7300 
    args.read(iprot)
7301 
    iprot.readMessageEnd()
7302 
    result = updateItemHoldInventory_result()
7303 
    self._handler.updateItemHoldInventory(args.itemHoldMap)
7304 
    oprot.writeMessageBegin("updateItemHoldInventory", TMessageType.REPLY, seqid)
7305 
    result.write(oprot)
7306 
    oprot.writeMessageEnd()
7307 
    oprot.trans.flush()
9776 vikram.rag 7308 
 
9861 rajveer 7309 
 
5944 mandeep.dh 7310 
# HELPER FUNCTIONS AND STRUCTURES
7311 
 
7312 
class addItem_args:
7313 
  """
7314 
  Attributes:
7315 
   - item
7316 
  """
7317 
 
7318 
  thrift_spec = (
7319 
    None, # 0
7320 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7321 
  )
7322 
 
7323 
  def __init__(self, item=None,):
7324 
    self.item = item
7325 
 
7326 
  def read(self, iprot):
7327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7329 
      return
7330 
    iprot.readStructBegin()
7331 
    while True:
7332 
      (fname, ftype, fid) = iprot.readFieldBegin()
7333 
      if ftype == TType.STOP:
7334 
        break
7335 
      if fid == 1:
7336 
        if ftype == TType.STRUCT:
7337 
          self.item = Item()
7338 
          self.item.read(iprot)
7339 
        else:
7340 
          iprot.skip(ftype)
7341 
      else:
7342 
        iprot.skip(ftype)
7343 
      iprot.readFieldEnd()
7344 
    iprot.readStructEnd()
7345 
 
7346 
  def write(self, oprot):
7347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7349 
      return
7350 
    oprot.writeStructBegin('addItem_args')
7351 
    if self.item is not None:
7352 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7353 
      self.item.write(oprot)
7354 
      oprot.writeFieldEnd()
7355 
    oprot.writeFieldStop()
7356 
    oprot.writeStructEnd()
7357 
 
7358 
  def validate(self):
7359 
    return
7360 
 
7361 
 
7362 
  def __repr__(self):
7363 
    L = ['%s=%r' % (key, value)
7364 
      for key, value in self.__dict__.iteritems()]
7365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7366 
 
7367 
  def __eq__(self, other):
7368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7369 
 
7370 
  def __ne__(self, other):
7371 
    return not (self == other)
7372 
 
7373 
class addItem_result:
7374 
  """
7375 
  Attributes:
7376 
   - success
7377 
   - cex
7378 
  """
7379 
 
7380 
  thrift_spec = (
7381 
    (0, TType.I64, 'success', None, None, ), # 0
7382 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7383 
  )
7384 
 
7385 
  def __init__(self, success=None, cex=None,):
7386 
    self.success = success
7387 
    self.cex = cex
7388 
 
7389 
  def read(self, iprot):
7390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7392 
      return
7393 
    iprot.readStructBegin()
7394 
    while True:
7395 
      (fname, ftype, fid) = iprot.readFieldBegin()
7396 
      if ftype == TType.STOP:
7397 
        break
7398 
      if fid == 0:
7399 
        if ftype == TType.I64:
7400 
          self.success = iprot.readI64();
7401 
        else:
7402 
          iprot.skip(ftype)
7403 
      elif fid == 1:
7404 
        if ftype == TType.STRUCT:
7405 
          self.cex = CatalogServiceException()
7406 
          self.cex.read(iprot)
7407 
        else:
7408 
          iprot.skip(ftype)
7409 
      else:
7410 
        iprot.skip(ftype)
7411 
      iprot.readFieldEnd()
7412 
    iprot.readStructEnd()
7413 
 
7414 
  def write(self, oprot):
7415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7417 
      return
7418 
    oprot.writeStructBegin('addItem_result')
7419 
    if self.success is not None:
7420 
      oprot.writeFieldBegin('success', TType.I64, 0)
7421 
      oprot.writeI64(self.success)
7422 
      oprot.writeFieldEnd()
7423 
    if self.cex is not None:
7424 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7425 
      self.cex.write(oprot)
7426 
      oprot.writeFieldEnd()
7427 
    oprot.writeFieldStop()
7428 
    oprot.writeStructEnd()
7429 
 
7430 
  def validate(self):
7431 
    return
7432 
 
7433 
 
7434 
  def __repr__(self):
7435 
    L = ['%s=%r' % (key, value)
7436 
      for key, value in self.__dict__.iteritems()]
7437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7438 
 
7439 
  def __eq__(self, other):
7440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7441 
 
7442 
  def __ne__(self, other):
7443 
    return not (self == other)
7444 
 
7445 
class updateItem_args:
7446 
  """
7447 
  Attributes:
7448 
   - item
7449 
  """
7450 
 
7451 
  thrift_spec = (
7452 
    None, # 0
7453 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7454 
  )
7455 
 
7456 
  def __init__(self, item=None,):
7457 
    self.item = item
7458 
 
7459 
  def read(self, iprot):
7460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7462 
      return
7463 
    iprot.readStructBegin()
7464 
    while True:
7465 
      (fname, ftype, fid) = iprot.readFieldBegin()
7466 
      if ftype == TType.STOP:
7467 
        break
7468 
      if fid == 1:
7469 
        if ftype == TType.STRUCT:
7470 
          self.item = Item()
7471 
          self.item.read(iprot)
7472 
        else:
7473 
          iprot.skip(ftype)
7474 
      else:
7475 
        iprot.skip(ftype)
7476 
      iprot.readFieldEnd()
7477 
    iprot.readStructEnd()
7478 
 
7479 
  def write(self, oprot):
7480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7482 
      return
7483 
    oprot.writeStructBegin('updateItem_args')
7484 
    if self.item is not None:
7485 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7486 
      self.item.write(oprot)
7487 
      oprot.writeFieldEnd()
7488 
    oprot.writeFieldStop()
7489 
    oprot.writeStructEnd()
7490 
 
7491 
  def validate(self):
7492 
    return
7493 
 
7494 
 
7495 
  def __repr__(self):
7496 
    L = ['%s=%r' % (key, value)
7497 
      for key, value in self.__dict__.iteritems()]
7498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7499 
 
7500 
  def __eq__(self, other):
7501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7502 
 
7503 
  def __ne__(self, other):
7504 
    return not (self == other)
7505 
 
7506 
class updateItem_result:
7507 
  """
7508 
  Attributes:
7509 
   - success
7510 
   - cex
7511 
  """
7512 
 
7513 
  thrift_spec = (
7514 
    (0, TType.I64, 'success', None, None, ), # 0
7515 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7516 
  )
7517 
 
7518 
  def __init__(self, success=None, cex=None,):
7519 
    self.success = success
7520 
    self.cex = cex
7521 
 
7522 
  def read(self, iprot):
7523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7525 
      return
7526 
    iprot.readStructBegin()
7527 
    while True:
7528 
      (fname, ftype, fid) = iprot.readFieldBegin()
7529 
      if ftype == TType.STOP:
7530 
        break
7531 
      if fid == 0:
7532 
        if ftype == TType.I64:
7533 
          self.success = iprot.readI64();
7534 
        else:
7535 
          iprot.skip(ftype)
7536 
      elif fid == 1:
7537 
        if ftype == TType.STRUCT:
7538 
          self.cex = CatalogServiceException()
7539 
          self.cex.read(iprot)
7540 
        else:
7541 
          iprot.skip(ftype)
7542 
      else:
7543 
        iprot.skip(ftype)
7544 
      iprot.readFieldEnd()
7545 
    iprot.readStructEnd()
7546 
 
7547 
  def write(self, oprot):
7548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7550 
      return
7551 
    oprot.writeStructBegin('updateItem_result')
7552 
    if self.success is not None:
7553 
      oprot.writeFieldBegin('success', TType.I64, 0)
7554 
      oprot.writeI64(self.success)
7555 
      oprot.writeFieldEnd()
7556 
    if self.cex is not None:
7557 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7558 
      self.cex.write(oprot)
7559 
      oprot.writeFieldEnd()
7560 
    oprot.writeFieldStop()
7561 
    oprot.writeStructEnd()
7562 
 
7563 
  def validate(self):
7564 
    return
7565 
 
7566 
 
7567 
  def __repr__(self):
7568 
    L = ['%s=%r' % (key, value)
7569 
      for key, value in self.__dict__.iteritems()]
7570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7571 
 
7572 
  def __eq__(self, other):
7573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7574 
 
7575 
  def __ne__(self, other):
7576 
    return not (self == other)
7577 
 
7578 
class isActive_args:
7579 
  """
7580 
  Attributes:
7581 
   - itemId
7582 
  """
7583 
 
7584 
  thrift_spec = (
7585 
    None, # 0
7586 
    (1, TType.I64, 'itemId', None, None, ), # 1
7587 
  )
7588 
 
7589 
  def __init__(self, itemId=None,):
7590 
    self.itemId = itemId
7591 
 
7592 
  def read(self, iprot):
7593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7595 
      return
7596 
    iprot.readStructBegin()
7597 
    while True:
7598 
      (fname, ftype, fid) = iprot.readFieldBegin()
7599 
      if ftype == TType.STOP:
7600 
        break
7601 
      if fid == 1:
7602 
        if ftype == TType.I64:
7603 
          self.itemId = iprot.readI64();
7604 
        else:
7605 
          iprot.skip(ftype)
7606 
      else:
7607 
        iprot.skip(ftype)
7608 
      iprot.readFieldEnd()
7609 
    iprot.readStructEnd()
7610 
 
7611 
  def write(self, oprot):
7612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7614 
      return
7615 
    oprot.writeStructBegin('isActive_args')
7616 
    if self.itemId is not None:
7617 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7618 
      oprot.writeI64(self.itemId)
7619 
      oprot.writeFieldEnd()
7620 
    oprot.writeFieldStop()
7621 
    oprot.writeStructEnd()
7622 
 
7623 
  def validate(self):
7624 
    return
7625 
 
7626 
 
7627 
  def __repr__(self):
7628 
    L = ['%s=%r' % (key, value)
7629 
      for key, value in self.__dict__.iteritems()]
7630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7631 
 
7632 
  def __eq__(self, other):
7633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7634 
 
7635 
  def __ne__(self, other):
7636 
    return not (self == other)
7637 
 
7638 
class isActive_result:
7639 
  """
7640 
  Attributes:
7641 
   - success
7642 
   - isex
7643 
  """
7644 
 
7645 
  thrift_spec = (
7646 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
7647 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7648 
  )
7649 
 
7650 
  def __init__(self, success=None, isex=None,):
7651 
    self.success = success
7652 
    self.isex = isex
7653 
 
7654 
  def read(self, iprot):
7655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7657 
      return
7658 
    iprot.readStructBegin()
7659 
    while True:
7660 
      (fname, ftype, fid) = iprot.readFieldBegin()
7661 
      if ftype == TType.STOP:
7662 
        break
7663 
      if fid == 0:
7664 
        if ftype == TType.STRUCT:
7665 
          self.success = ItemShippingInfo()
7666 
          self.success.read(iprot)
7667 
        else:
7668 
          iprot.skip(ftype)
7669 
      elif fid == 1:
7670 
        if ftype == TType.STRUCT:
7671 
          self.isex = CatalogServiceException()
7672 
          self.isex.read(iprot)
7673 
        else:
7674 
          iprot.skip(ftype)
7675 
      else:
7676 
        iprot.skip(ftype)
7677 
      iprot.readFieldEnd()
7678 
    iprot.readStructEnd()
7679 
 
7680 
  def write(self, oprot):
7681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7683 
      return
7684 
    oprot.writeStructBegin('isActive_result')
7685 
    if self.success is not None:
7686 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7687 
      self.success.write(oprot)
7688 
      oprot.writeFieldEnd()
7689 
    if self.isex is not None:
7690 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7691 
      self.isex.write(oprot)
7692 
      oprot.writeFieldEnd()
7693 
    oprot.writeFieldStop()
7694 
    oprot.writeStructEnd()
7695 
 
7696 
  def validate(self):
7697 
    return
7698 
 
7699 
 
7700 
  def __repr__(self):
7701 
    L = ['%s=%r' % (key, value)
7702 
      for key, value in self.__dict__.iteritems()]
7703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7704 
 
7705 
  def __eq__(self, other):
7706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7707 
 
7708 
  def __ne__(self, other):
7709 
    return not (self == other)
7710 
 
7438 amit.gupta 7711 
class getItemsStatus_args:
7712 
  """
7713 
  Attributes:
7714 
   - itemIds
7715 
  """
7716 
 
7717 
  thrift_spec = (
7718 
    None, # 0
7719 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
7720 
  )
7721 
 
7722 
  def __init__(self, itemIds=None,):
7723 
    self.itemIds = itemIds
7724 
 
7725 
  def read(self, iprot):
7726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7728 
      return
7729 
    iprot.readStructBegin()
7730 
    while True:
7731 
      (fname, ftype, fid) = iprot.readFieldBegin()
7732 
      if ftype == TType.STOP:
7733 
        break
7734 
      if fid == 1:
7735 
        if ftype == TType.LIST:
7736 
          self.itemIds = []
8590 kshitij.so 7737 
          (_etype33, _size30) = iprot.readListBegin()
7738 
          for _i34 in xrange(_size30):
7739 
            _elem35 = iprot.readI64();
7740 
            self.itemIds.append(_elem35)
7438 amit.gupta 7741 
          iprot.readListEnd()
7742 
        else:
7743 
          iprot.skip(ftype)
7744 
      else:
7745 
        iprot.skip(ftype)
7746 
      iprot.readFieldEnd()
7747 
    iprot.readStructEnd()
7748 
 
7749 
  def write(self, oprot):
7750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7752 
      return
7753 
    oprot.writeStructBegin('getItemsStatus_args')
7754 
    if self.itemIds is not None:
7755 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
7756 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 7757 
      for iter36 in self.itemIds:
7758 
        oprot.writeI64(iter36)
7438 amit.gupta 7759 
      oprot.writeListEnd()
7760 
      oprot.writeFieldEnd()
7761 
    oprot.writeFieldStop()
7762 
    oprot.writeStructEnd()
7763 
 
7764 
  def validate(self):
7765 
    return
7766 
 
7767 
 
7768 
  def __repr__(self):
7769 
    L = ['%s=%r' % (key, value)
7770 
      for key, value in self.__dict__.iteritems()]
7771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7772 
 
7773 
  def __eq__(self, other):
7774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7775 
 
7776 
  def __ne__(self, other):
7777 
    return not (self == other)
7778 
 
7779 
class getItemsStatus_result:
7780 
  """
7781 
  Attributes:
7782 
   - success
7783 
   - isex
7784 
  """
7785 
 
7786 
  thrift_spec = (
7787 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
7788 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7789 
  )
7790 
 
7791 
  def __init__(self, success=None, isex=None,):
7792 
    self.success = success
7793 
    self.isex = isex
7794 
 
7795 
  def read(self, iprot):
7796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7798 
      return
7799 
    iprot.readStructBegin()
7800 
    while True:
7801 
      (fname, ftype, fid) = iprot.readFieldBegin()
7802 
      if ftype == TType.STOP:
7803 
        break
7804 
      if fid == 0:
7805 
        if ftype == TType.MAP:
7806 
          self.success = {}
8590 kshitij.so 7807 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
7808 
          for _i41 in xrange(_size37):
7809 
            _key42 = iprot.readI64();
7810 
            _val43 = iprot.readBool();
7811 
            self.success[_key42] = _val43
7438 amit.gupta 7812 
          iprot.readMapEnd()
7813 
        else:
7814 
          iprot.skip(ftype)
7815 
      elif fid == 1:
7816 
        if ftype == TType.STRUCT:
7817 
          self.isex = CatalogServiceException()
7818 
          self.isex.read(iprot)
7819 
        else:
7820 
          iprot.skip(ftype)
7821 
      else:
7822 
        iprot.skip(ftype)
7823 
      iprot.readFieldEnd()
7824 
    iprot.readStructEnd()
7825 
 
7826 
  def write(self, oprot):
7827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7829 
      return
7830 
    oprot.writeStructBegin('getItemsStatus_result')
7831 
    if self.success is not None:
7832 
      oprot.writeFieldBegin('success', TType.MAP, 0)
7833 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 7834 
      for kiter44,viter45 in self.success.items():
7835 
        oprot.writeI64(kiter44)
7836 
        oprot.writeBool(viter45)
7438 amit.gupta 7837 
      oprot.writeMapEnd()
7838 
      oprot.writeFieldEnd()
7839 
    if self.isex is not None:
7840 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7841 
      self.isex.write(oprot)
7842 
      oprot.writeFieldEnd()
7843 
    oprot.writeFieldStop()
7844 
    oprot.writeStructEnd()
7845 
 
7846 
  def validate(self):
7847 
    return
7848 
 
7849 
 
7850 
  def __repr__(self):
7851 
    L = ['%s=%r' % (key, value)
7852 
      for key, value in self.__dict__.iteritems()]
7853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7854 
 
7855 
  def __eq__(self, other):
7856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7857 
 
7858 
  def __ne__(self, other):
7859 
    return not (self == other)
7860 
 
5944 mandeep.dh 7861 
class getItemStatusDescription_args:
7862 
  """
7863 
  Attributes:
7864 
   - itemId
7865 
  """
7866 
 
7867 
  thrift_spec = (
7868 
    None, # 0
7869 
    (1, TType.I64, 'itemId', None, None, ), # 1
7870 
  )
7871 
 
7872 
  def __init__(self, itemId=None,):
7873 
    self.itemId = itemId
7874 
 
7875 
  def read(self, iprot):
7876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7878 
      return
7879 
    iprot.readStructBegin()
7880 
    while True:
7881 
      (fname, ftype, fid) = iprot.readFieldBegin()
7882 
      if ftype == TType.STOP:
7883 
        break
7884 
      if fid == 1:
7885 
        if ftype == TType.I64:
7886 
          self.itemId = iprot.readI64();
7887 
        else:
7888 
          iprot.skip(ftype)
7889 
      else:
7890 
        iprot.skip(ftype)
7891 
      iprot.readFieldEnd()
7892 
    iprot.readStructEnd()
7893 
 
7894 
  def write(self, oprot):
7895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7897 
      return
7898 
    oprot.writeStructBegin('getItemStatusDescription_args')
7899 
    if self.itemId is not None:
7900 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7901 
      oprot.writeI64(self.itemId)
7902 
      oprot.writeFieldEnd()
7903 
    oprot.writeFieldStop()
7904 
    oprot.writeStructEnd()
7905 
 
7906 
  def validate(self):
7907 
    return
7908 
 
7909 
 
7910 
  def __repr__(self):
7911 
    L = ['%s=%r' % (key, value)
7912 
      for key, value in self.__dict__.iteritems()]
7913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7914 
 
7915 
  def __eq__(self, other):
7916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7917 
 
7918 
  def __ne__(self, other):
7919 
    return not (self == other)
7920 
 
7921 
class getItemStatusDescription_result:
7922 
  """
7923 
  Attributes:
7924 
   - success
7925 
   - isex
7926 
  """
7927 
 
7928 
  thrift_spec = (
7929 
    (0, TType.STRING, 'success', None, None, ), # 0
7930 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7931 
  )
7932 
 
7933 
  def __init__(self, success=None, isex=None,):
7934 
    self.success = success
7935 
    self.isex = isex
7936 
 
7937 
  def read(self, iprot):
7938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7940 
      return
7941 
    iprot.readStructBegin()
7942 
    while True:
7943 
      (fname, ftype, fid) = iprot.readFieldBegin()
7944 
      if ftype == TType.STOP:
7945 
        break
7946 
      if fid == 0:
7947 
        if ftype == TType.STRING:
7948 
          self.success = iprot.readString();
7949 
        else:
7950 
          iprot.skip(ftype)
7951 
      elif fid == 1:
7952 
        if ftype == TType.STRUCT:
7953 
          self.isex = CatalogServiceException()
7954 
          self.isex.read(iprot)
7955 
        else:
7956 
          iprot.skip(ftype)
7957 
      else:
7958 
        iprot.skip(ftype)
7959 
      iprot.readFieldEnd()
7960 
    iprot.readStructEnd()
7961 
 
7962 
  def write(self, oprot):
7963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7965 
      return
7966 
    oprot.writeStructBegin('getItemStatusDescription_result')
7967 
    if self.success is not None:
7968 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7969 
      oprot.writeString(self.success)
7970 
      oprot.writeFieldEnd()
7971 
    if self.isex is not None:
7972 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7973 
      self.isex.write(oprot)
7974 
      oprot.writeFieldEnd()
7975 
    oprot.writeFieldStop()
7976 
    oprot.writeStructEnd()
7977 
 
7978 
  def validate(self):
7979 
    return
7980 
 
7981 
 
7982 
  def __repr__(self):
7983 
    L = ['%s=%r' % (key, value)
7984 
      for key, value in self.__dict__.iteritems()]
7985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7986 
 
7987 
  def __eq__(self, other):
7988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7989 
 
7990 
  def __ne__(self, other):
7991 
    return not (self == other)
7992 
 
7993 
class startItemOn_args:
7994 
  """
7995 
  Attributes:
7996 
   - item_id
7997 
   - timestamp
7998 
  """
7999 
 
8000 
  thrift_spec = (
8001 
    None, # 0
8002 
    (1, TType.I64, 'item_id', None, None, ), # 1
8003 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8004 
  )
8005 
 
8006 
  def __init__(self, item_id=None, timestamp=None,):
8007 
    self.item_id = item_id
8008 
    self.timestamp = timestamp
8009 
 
8010 
  def read(self, iprot):
8011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8013 
      return
8014 
    iprot.readStructBegin()
8015 
    while True:
8016 
      (fname, ftype, fid) = iprot.readFieldBegin()
8017 
      if ftype == TType.STOP:
8018 
        break
8019 
      if fid == 1:
8020 
        if ftype == TType.I64:
8021 
          self.item_id = iprot.readI64();
8022 
        else:
8023 
          iprot.skip(ftype)
8024 
      elif fid == 2:
8025 
        if ftype == TType.I64:
8026 
          self.timestamp = iprot.readI64();
8027 
        else:
8028 
          iprot.skip(ftype)
8029 
      else:
8030 
        iprot.skip(ftype)
8031 
      iprot.readFieldEnd()
8032 
    iprot.readStructEnd()
8033 
 
8034 
  def write(self, oprot):
8035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8037 
      return
8038 
    oprot.writeStructBegin('startItemOn_args')
8039 
    if self.item_id is not None:
8040 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8041 
      oprot.writeI64(self.item_id)
8042 
      oprot.writeFieldEnd()
8043 
    if self.timestamp is not None:
8044 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8045 
      oprot.writeI64(self.timestamp)
8046 
      oprot.writeFieldEnd()
8047 
    oprot.writeFieldStop()
8048 
    oprot.writeStructEnd()
8049 
 
8050 
  def validate(self):
8051 
    return
8052 
 
8053 
 
8054 
  def __repr__(self):
8055 
    L = ['%s=%r' % (key, value)
8056 
      for key, value in self.__dict__.iteritems()]
8057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8058 
 
8059 
  def __eq__(self, other):
8060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8061 
 
8062 
  def __ne__(self, other):
8063 
    return not (self == other)
8064 
 
8065 
class startItemOn_result:
8066 
  """
8067 
  Attributes:
8068 
   - cex
8069 
  """
8070 
 
8071 
  thrift_spec = (
8072 
    None, # 0
8073 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8074 
  )
8075 
 
8076 
  def __init__(self, cex=None,):
8077 
    self.cex = cex
8078 
 
8079 
  def read(self, iprot):
8080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8082 
      return
8083 
    iprot.readStructBegin()
8084 
    while True:
8085 
      (fname, ftype, fid) = iprot.readFieldBegin()
8086 
      if ftype == TType.STOP:
8087 
        break
8088 
      if fid == 1:
8089 
        if ftype == TType.STRUCT:
8090 
          self.cex = CatalogServiceException()
8091 
          self.cex.read(iprot)
8092 
        else:
8093 
          iprot.skip(ftype)
8094 
      else:
8095 
        iprot.skip(ftype)
8096 
      iprot.readFieldEnd()
8097 
    iprot.readStructEnd()
8098 
 
8099 
  def write(self, oprot):
8100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8102 
      return
8103 
    oprot.writeStructBegin('startItemOn_result')
8104 
    if self.cex is not None:
8105 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8106 
      self.cex.write(oprot)
8107 
      oprot.writeFieldEnd()
8108 
    oprot.writeFieldStop()
8109 
    oprot.writeStructEnd()
8110 
 
8111 
  def validate(self):
8112 
    return
8113 
 
8114 
 
8115 
  def __repr__(self):
8116 
    L = ['%s=%r' % (key, value)
8117 
      for key, value in self.__dict__.iteritems()]
8118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8119 
 
8120 
  def __eq__(self, other):
8121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8122 
 
8123 
  def __ne__(self, other):
8124 
    return not (self == other)
8125 
 
8126 
class retireItemOn_args:
8127 
  """
8128 
  Attributes:
8129 
   - item_id
8130 
   - timestamp
8131 
  """
8132 
 
8133 
  thrift_spec = (
8134 
    None, # 0
8135 
    (1, TType.I64, 'item_id', None, None, ), # 1
8136 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8137 
  )
8138 
 
8139 
  def __init__(self, item_id=None, timestamp=None,):
8140 
    self.item_id = item_id
8141 
    self.timestamp = timestamp
8142 
 
8143 
  def read(self, iprot):
8144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8146 
      return
8147 
    iprot.readStructBegin()
8148 
    while True:
8149 
      (fname, ftype, fid) = iprot.readFieldBegin()
8150 
      if ftype == TType.STOP:
8151 
        break
8152 
      if fid == 1:
8153 
        if ftype == TType.I64:
8154 
          self.item_id = iprot.readI64();
8155 
        else:
8156 
          iprot.skip(ftype)
8157 
      elif fid == 2:
8158 
        if ftype == TType.I64:
8159 
          self.timestamp = iprot.readI64();
8160 
        else:
8161 
          iprot.skip(ftype)
8162 
      else:
8163 
        iprot.skip(ftype)
8164 
      iprot.readFieldEnd()
8165 
    iprot.readStructEnd()
8166 
 
8167 
  def write(self, oprot):
8168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8170 
      return
8171 
    oprot.writeStructBegin('retireItemOn_args')
8172 
    if self.item_id is not None:
8173 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8174 
      oprot.writeI64(self.item_id)
8175 
      oprot.writeFieldEnd()
8176 
    if self.timestamp is not None:
8177 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8178 
      oprot.writeI64(self.timestamp)
8179 
      oprot.writeFieldEnd()
8180 
    oprot.writeFieldStop()
8181 
    oprot.writeStructEnd()
8182 
 
8183 
  def validate(self):
8184 
    return
8185 
 
8186 
 
8187 
  def __repr__(self):
8188 
    L = ['%s=%r' % (key, value)
8189 
      for key, value in self.__dict__.iteritems()]
8190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8191 
 
8192 
  def __eq__(self, other):
8193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8194 
 
8195 
  def __ne__(self, other):
8196 
    return not (self == other)
8197 
 
8198 
class retireItemOn_result:
8199 
  """
8200 
  Attributes:
8201 
   - cex
8202 
  """
8203 
 
8204 
  thrift_spec = (
8205 
    None, # 0
8206 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8207 
  )
8208 
 
8209 
  def __init__(self, cex=None,):
8210 
    self.cex = cex
8211 
 
8212 
  def read(self, iprot):
8213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8215 
      return
8216 
    iprot.readStructBegin()
8217 
    while True:
8218 
      (fname, ftype, fid) = iprot.readFieldBegin()
8219 
      if ftype == TType.STOP:
8220 
        break
8221 
      if fid == 1:
8222 
        if ftype == TType.STRUCT:
8223 
          self.cex = CatalogServiceException()
8224 
          self.cex.read(iprot)
8225 
        else:
8226 
          iprot.skip(ftype)
8227 
      else:
8228 
        iprot.skip(ftype)
8229 
      iprot.readFieldEnd()
8230 
    iprot.readStructEnd()
8231 
 
8232 
  def write(self, oprot):
8233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8235 
      return
8236 
    oprot.writeStructBegin('retireItemOn_result')
8237 
    if self.cex is not None:
8238 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8239 
      self.cex.write(oprot)
8240 
      oprot.writeFieldEnd()
8241 
    oprot.writeFieldStop()
8242 
    oprot.writeStructEnd()
8243 
 
8244 
  def validate(self):
8245 
    return
8246 
 
8247 
 
8248 
  def __repr__(self):
8249 
    L = ['%s=%r' % (key, value)
8250 
      for key, value in self.__dict__.iteritems()]
8251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8252 
 
8253 
  def __eq__(self, other):
8254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8255 
 
8256 
  def __ne__(self, other):
8257 
    return not (self == other)
8258 
 
8259 
class changeItemStatus_args:
8260 
  """
8261 
  Attributes:
8262 
   - item_id
8263 
   - timestamp
8264 
   - newstatus
8265 
  """
8266 
 
8267 
  thrift_spec = (
8268 
    None, # 0
8269 
    (1, TType.I64, 'item_id', None, None, ), # 1
8270 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8271 
    (3, TType.I32, 'newstatus', None, None, ), # 3
8272 
  )
8273 
 
8274 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
8275 
    self.item_id = item_id
8276 
    self.timestamp = timestamp
8277 
    self.newstatus = newstatus
8278 
 
8279 
  def read(self, iprot):
8280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8282 
      return
8283 
    iprot.readStructBegin()
8284 
    while True:
8285 
      (fname, ftype, fid) = iprot.readFieldBegin()
8286 
      if ftype == TType.STOP:
8287 
        break
8288 
      if fid == 1:
8289 
        if ftype == TType.I64:
8290 
          self.item_id = iprot.readI64();
8291 
        else:
8292 
          iprot.skip(ftype)
8293 
      elif fid == 2:
8294 
        if ftype == TType.I64:
8295 
          self.timestamp = iprot.readI64();
8296 
        else:
8297 
          iprot.skip(ftype)
8298 
      elif fid == 3:
8299 
        if ftype == TType.I32:
8300 
          self.newstatus = iprot.readI32();
8301 
        else:
8302 
          iprot.skip(ftype)
8303 
      else:
8304 
        iprot.skip(ftype)
8305 
      iprot.readFieldEnd()
8306 
    iprot.readStructEnd()
8307 
 
8308 
  def write(self, oprot):
8309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8311 
      return
8312 
    oprot.writeStructBegin('changeItemStatus_args')
8313 
    if self.item_id is not None:
8314 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8315 
      oprot.writeI64(self.item_id)
8316 
      oprot.writeFieldEnd()
8317 
    if self.timestamp is not None:
8318 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8319 
      oprot.writeI64(self.timestamp)
8320 
      oprot.writeFieldEnd()
8321 
    if self.newstatus is not None:
8322 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
8323 
      oprot.writeI32(self.newstatus)
8324 
      oprot.writeFieldEnd()
8325 
    oprot.writeFieldStop()
8326 
    oprot.writeStructEnd()
8327 
 
8328 
  def validate(self):
8329 
    return
8330 
 
8331 
 
8332 
  def __repr__(self):
8333 
    L = ['%s=%r' % (key, value)
8334 
      for key, value in self.__dict__.iteritems()]
8335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8336 
 
8337 
  def __eq__(self, other):
8338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8339 
 
8340 
  def __ne__(self, other):
8341 
    return not (self == other)
8342 
 
8343 
class changeItemStatus_result:
8344 
  """
8345 
  Attributes:
8346 
   - cex
8347 
  """
8348 
 
8349 
  thrift_spec = (
8350 
    None, # 0
8351 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8352 
  )
8353 
 
8354 
  def __init__(self, cex=None,):
8355 
    self.cex = cex
8356 
 
8357 
  def read(self, iprot):
8358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8360 
      return
8361 
    iprot.readStructBegin()
8362 
    while True:
8363 
      (fname, ftype, fid) = iprot.readFieldBegin()
8364 
      if ftype == TType.STOP:
8365 
        break
8366 
      if fid == 1:
8367 
        if ftype == TType.STRUCT:
8368 
          self.cex = CatalogServiceException()
8369 
          self.cex.read(iprot)
8370 
        else:
8371 
          iprot.skip(ftype)
8372 
      else:
8373 
        iprot.skip(ftype)
8374 
      iprot.readFieldEnd()
8375 
    iprot.readStructEnd()
8376 
 
8377 
  def write(self, oprot):
8378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8380 
      return
8381 
    oprot.writeStructBegin('changeItemStatus_result')
8382 
    if self.cex is not None:
8383 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8384 
      self.cex.write(oprot)
8385 
      oprot.writeFieldEnd()
8386 
    oprot.writeFieldStop()
8387 
    oprot.writeStructEnd()
8388 
 
8389 
  def validate(self):
8390 
    return
8391 
 
8392 
 
8393 
  def __repr__(self):
8394 
    L = ['%s=%r' % (key, value)
8395 
      for key, value in self.__dict__.iteritems()]
8396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8397 
 
8398 
  def __eq__(self, other):
8399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8400 
 
8401 
  def __ne__(self, other):
8402 
    return not (self == other)
8403 
 
8404 
class getItem_args:
8405 
  """
8406 
  Attributes:
8407 
   - item_id
8408 
  """
8409 
 
8410 
  thrift_spec = (
8411 
    None, # 0
8412 
    (1, TType.I64, 'item_id', None, None, ), # 1
8413 
  )
8414 
 
8415 
  def __init__(self, item_id=None,):
8416 
    self.item_id = item_id
8417 
 
8418 
  def read(self, iprot):
8419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8421 
      return
8422 
    iprot.readStructBegin()
8423 
    while True:
8424 
      (fname, ftype, fid) = iprot.readFieldBegin()
8425 
      if ftype == TType.STOP:
8426 
        break
8427 
      if fid == 1:
8428 
        if ftype == TType.I64:
8429 
          self.item_id = iprot.readI64();
8430 
        else:
8431 
          iprot.skip(ftype)
8432 
      else:
8433 
        iprot.skip(ftype)
8434 
      iprot.readFieldEnd()
8435 
    iprot.readStructEnd()
8436 
 
8437 
  def write(self, oprot):
8438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8440 
      return
8441 
    oprot.writeStructBegin('getItem_args')
8442 
    if self.item_id is not None:
8443 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8444 
      oprot.writeI64(self.item_id)
8445 
      oprot.writeFieldEnd()
8446 
    oprot.writeFieldStop()
8447 
    oprot.writeStructEnd()
8448 
 
8449 
  def validate(self):
8450 
    return
8451 
 
8452 
 
8453 
  def __repr__(self):
8454 
    L = ['%s=%r' % (key, value)
8455 
      for key, value in self.__dict__.iteritems()]
8456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8457 
 
8458 
  def __eq__(self, other):
8459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8460 
 
8461 
  def __ne__(self, other):
8462 
    return not (self == other)
8463 
 
8464 
class getItem_result:
8465 
  """
8466 
  Attributes:
8467 
   - success
8468 
   - cex
8469 
  """
8470 
 
8471 
  thrift_spec = (
8472 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
8473 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8474 
  )
8475 
 
8476 
  def __init__(self, success=None, cex=None,):
8477 
    self.success = success
8478 
    self.cex = cex
8479 
 
8480 
  def read(self, iprot):
8481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8483 
      return
8484 
    iprot.readStructBegin()
8485 
    while True:
8486 
      (fname, ftype, fid) = iprot.readFieldBegin()
8487 
      if ftype == TType.STOP:
8488 
        break
8489 
      if fid == 0:
8490 
        if ftype == TType.STRUCT:
8491 
          self.success = Item()
8492 
          self.success.read(iprot)
8493 
        else:
8494 
          iprot.skip(ftype)
8495 
      elif fid == 1:
8496 
        if ftype == TType.STRUCT:
8497 
          self.cex = CatalogServiceException()
8498 
          self.cex.read(iprot)
8499 
        else:
8500 
          iprot.skip(ftype)
8501 
      else:
8502 
        iprot.skip(ftype)
8503 
      iprot.readFieldEnd()
8504 
    iprot.readStructEnd()
8505 
 
8506 
  def write(self, oprot):
8507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8509 
      return
8510 
    oprot.writeStructBegin('getItem_result')
8511 
    if self.success is not None:
8512 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8513 
      self.success.write(oprot)
8514 
      oprot.writeFieldEnd()
8515 
    if self.cex is not None:
8516 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8517 
      self.cex.write(oprot)
8518 
      oprot.writeFieldEnd()
8519 
    oprot.writeFieldStop()
8520 
    oprot.writeStructEnd()
8521 
 
8522 
  def validate(self):
8523 
    return
8524 
 
8525 
 
8526 
  def __repr__(self):
8527 
    L = ['%s=%r' % (key, value)
8528 
      for key, value in self.__dict__.iteritems()]
8529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8530 
 
8531 
  def __eq__(self, other):
8532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8533 
 
8534 
  def __ne__(self, other):
8535 
    return not (self == other)
8536 
 
8537 
class getItemsByCatalogId_args:
8538 
  """
8539 
  Attributes:
8540 
   - catalog_item_id
8541 
  """
8542 
 
8543 
  thrift_spec = (
8544 
    None, # 0
8545 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8546 
  )
8547 
 
8548 
  def __init__(self, catalog_item_id=None,):
8549 
    self.catalog_item_id = catalog_item_id
8550 
 
8551 
  def read(self, iprot):
8552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8554 
      return
8555 
    iprot.readStructBegin()
8556 
    while True:
8557 
      (fname, ftype, fid) = iprot.readFieldBegin()
8558 
      if ftype == TType.STOP:
8559 
        break
8560 
      if fid == 1:
8561 
        if ftype == TType.I64:
8562 
          self.catalog_item_id = iprot.readI64();
8563 
        else:
8564 
          iprot.skip(ftype)
8565 
      else:
8566 
        iprot.skip(ftype)
8567 
      iprot.readFieldEnd()
8568 
    iprot.readStructEnd()
8569 
 
8570 
  def write(self, oprot):
8571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8573 
      return
8574 
    oprot.writeStructBegin('getItemsByCatalogId_args')
8575 
    if self.catalog_item_id is not None:
8576 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8577 
      oprot.writeI64(self.catalog_item_id)
8578 
      oprot.writeFieldEnd()
8579 
    oprot.writeFieldStop()
8580 
    oprot.writeStructEnd()
8581 
 
8582 
  def validate(self):
8583 
    return
8584 
 
8585 
 
8586 
  def __repr__(self):
8587 
    L = ['%s=%r' % (key, value)
8588 
      for key, value in self.__dict__.iteritems()]
8589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8590 
 
8591 
  def __eq__(self, other):
8592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8593 
 
8594 
  def __ne__(self, other):
8595 
    return not (self == other)
8596 
 
8597 
class getItemsByCatalogId_result:
8598 
  """
8599 
  Attributes:
8600 
   - success
8601 
   - cex
8602 
  """
8603 
 
8604 
  thrift_spec = (
8605 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8606 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8607 
  )
8608 
 
8609 
  def __init__(self, success=None, cex=None,):
8610 
    self.success = success
8611 
    self.cex = cex
8612 
 
8613 
  def read(self, iprot):
8614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8616 
      return
8617 
    iprot.readStructBegin()
8618 
    while True:
8619 
      (fname, ftype, fid) = iprot.readFieldBegin()
8620 
      if ftype == TType.STOP:
8621 
        break
8622 
      if fid == 0:
8623 
        if ftype == TType.LIST:
8624 
          self.success = []
8590 kshitij.so 8625 
          (_etype49, _size46) = iprot.readListBegin()
8626 
          for _i50 in xrange(_size46):
8627 
            _elem51 = Item()
8628 
            _elem51.read(iprot)
8629 
            self.success.append(_elem51)
5944 mandeep.dh 8630 
          iprot.readListEnd()
8631 
        else:
8632 
          iprot.skip(ftype)
8633 
      elif fid == 1:
8634 
        if ftype == TType.STRUCT:
8635 
          self.cex = CatalogServiceException()
8636 
          self.cex.read(iprot)
8637 
        else:
8638 
          iprot.skip(ftype)
8639 
      else:
8640 
        iprot.skip(ftype)
8641 
      iprot.readFieldEnd()
8642 
    iprot.readStructEnd()
8643 
 
8644 
  def write(self, oprot):
8645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8647 
      return
8648 
    oprot.writeStructBegin('getItemsByCatalogId_result')
8649 
    if self.success is not None:
8650 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8651 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8652 
      for iter52 in self.success:
8653 
        iter52.write(oprot)
5944 mandeep.dh 8654 
      oprot.writeListEnd()
8655 
      oprot.writeFieldEnd()
8656 
    if self.cex is not None:
8657 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8658 
      self.cex.write(oprot)
8659 
      oprot.writeFieldEnd()
8660 
    oprot.writeFieldStop()
8661 
    oprot.writeStructEnd()
8662 
 
8663 
  def validate(self):
8664 
    return
8665 
 
8666 
 
8667 
  def __repr__(self):
8668 
    L = ['%s=%r' % (key, value)
8669 
      for key, value in self.__dict__.iteritems()]
8670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8671 
 
8672 
  def __eq__(self, other):
8673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8674 
 
8675 
  def __ne__(self, other):
8676 
    return not (self == other)
8677 
 
8678 
class getValidItemsByCatalogId_args:
8679 
  """
8680 
  Attributes:
8681 
   - catalog_item_id
8682 
  """
8683 
 
8684 
  thrift_spec = (
8685 
    None, # 0
8686 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8687 
  )
8688 
 
8689 
  def __init__(self, catalog_item_id=None,):
8690 
    self.catalog_item_id = catalog_item_id
8691 
 
8692 
  def read(self, iprot):
8693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8695 
      return
8696 
    iprot.readStructBegin()
8697 
    while True:
8698 
      (fname, ftype, fid) = iprot.readFieldBegin()
8699 
      if ftype == TType.STOP:
8700 
        break
8701 
      if fid == 1:
8702 
        if ftype == TType.I64:
8703 
          self.catalog_item_id = iprot.readI64();
8704 
        else:
8705 
          iprot.skip(ftype)
8706 
      else:
8707 
        iprot.skip(ftype)
8708 
      iprot.readFieldEnd()
8709 
    iprot.readStructEnd()
8710 
 
8711 
  def write(self, oprot):
8712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8714 
      return
8715 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
8716 
    if self.catalog_item_id is not None:
8717 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8718 
      oprot.writeI64(self.catalog_item_id)
8719 
      oprot.writeFieldEnd()
8720 
    oprot.writeFieldStop()
8721 
    oprot.writeStructEnd()
8722 
 
8723 
  def validate(self):
8724 
    return
8725 
 
8726 
 
8727 
  def __repr__(self):
8728 
    L = ['%s=%r' % (key, value)
8729 
      for key, value in self.__dict__.iteritems()]
8730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8731 
 
8732 
  def __eq__(self, other):
8733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8734 
 
8735 
  def __ne__(self, other):
8736 
    return not (self == other)
8737 
 
8738 
class getValidItemsByCatalogId_result:
8739 
  """
8740 
  Attributes:
8741 
   - success
8742 
   - cex
8743 
  """
8744 
 
8745 
  thrift_spec = (
8746 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8747 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8748 
  )
8749 
 
8750 
  def __init__(self, success=None, cex=None,):
8751 
    self.success = success
8752 
    self.cex = cex
8753 
 
8754 
  def read(self, iprot):
8755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8757 
      return
8758 
    iprot.readStructBegin()
8759 
    while True:
8760 
      (fname, ftype, fid) = iprot.readFieldBegin()
8761 
      if ftype == TType.STOP:
8762 
        break
8763 
      if fid == 0:
8764 
        if ftype == TType.LIST:
8765 
          self.success = []
8590 kshitij.so 8766 
          (_etype56, _size53) = iprot.readListBegin()
8767 
          for _i57 in xrange(_size53):
8768 
            _elem58 = Item()
8769 
            _elem58.read(iprot)
8770 
            self.success.append(_elem58)
5944 mandeep.dh 8771 
          iprot.readListEnd()
8772 
        else:
8773 
          iprot.skip(ftype)
8774 
      elif fid == 1:
8775 
        if ftype == TType.STRUCT:
8776 
          self.cex = CatalogServiceException()
8777 
          self.cex.read(iprot)
8778 
        else:
8779 
          iprot.skip(ftype)
8780 
      else:
8781 
        iprot.skip(ftype)
8782 
      iprot.readFieldEnd()
8783 
    iprot.readStructEnd()
8784 
 
8785 
  def write(self, oprot):
8786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8788 
      return
8789 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
8790 
    if self.success is not None:
8791 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8792 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8793 
      for iter59 in self.success:
8794 
        iter59.write(oprot)
5944 mandeep.dh 8795 
      oprot.writeListEnd()
8796 
      oprot.writeFieldEnd()
8797 
    if self.cex is not None:
8798 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8799 
      self.cex.write(oprot)
8800 
      oprot.writeFieldEnd()
8801 
    oprot.writeFieldStop()
8802 
    oprot.writeStructEnd()
8803 
 
8804 
  def validate(self):
8805 
    return
8806 
 
8807 
 
8808 
  def __repr__(self):
8809 
    L = ['%s=%r' % (key, value)
8810 
      for key, value in self.__dict__.iteritems()]
8811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8812 
 
8813 
  def __eq__(self, other):
8814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8815 
 
8816 
  def __ne__(self, other):
8817 
    return not (self == other)
8818 
 
8819 
class getAllItems_args:
8820 
  """
8821 
  Attributes:
8822 
   - isActive
8823 
  """
8824 
 
8825 
  thrift_spec = (
8826 
    None, # 0
8827 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
8828 
  )
8829 
 
8830 
  def __init__(self, isActive=None,):
8831 
    self.isActive = isActive
8832 
 
8833 
  def read(self, iprot):
8834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8836 
      return
8837 
    iprot.readStructBegin()
8838 
    while True:
8839 
      (fname, ftype, fid) = iprot.readFieldBegin()
8840 
      if ftype == TType.STOP:
8841 
        break
8842 
      if fid == 1:
8843 
        if ftype == TType.BOOL:
8844 
          self.isActive = iprot.readBool();
8845 
        else:
8846 
          iprot.skip(ftype)
8847 
      else:
8848 
        iprot.skip(ftype)
8849 
      iprot.readFieldEnd()
8850 
    iprot.readStructEnd()
8851 
 
8852 
  def write(self, oprot):
8853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8855 
      return
8856 
    oprot.writeStructBegin('getAllItems_args')
8857 
    if self.isActive is not None:
8858 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
8859 
      oprot.writeBool(self.isActive)
8860 
      oprot.writeFieldEnd()
8861 
    oprot.writeFieldStop()
8862 
    oprot.writeStructEnd()
8863 
 
8864 
  def validate(self):
8865 
    return
8866 
 
8867 
 
8868 
  def __repr__(self):
8869 
    L = ['%s=%r' % (key, value)
8870 
      for key, value in self.__dict__.iteritems()]
8871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8872 
 
8873 
  def __eq__(self, other):
8874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8875 
 
8876 
  def __ne__(self, other):
8877 
    return not (self == other)
8878 
 
8879 
class getAllItems_result:
8880 
  """
8881 
  Attributes:
8882 
   - success
8883 
   - cex
8884 
  """
8885 
 
8886 
  thrift_spec = (
8887 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8888 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8889 
  )
8890 
 
8891 
  def __init__(self, success=None, cex=None,):
8892 
    self.success = success
8893 
    self.cex = cex
8894 
 
8895 
  def read(self, iprot):
8896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8898 
      return
8899 
    iprot.readStructBegin()
8900 
    while True:
8901 
      (fname, ftype, fid) = iprot.readFieldBegin()
8902 
      if ftype == TType.STOP:
8903 
        break
8904 
      if fid == 0:
8905 
        if ftype == TType.LIST:
8906 
          self.success = []
8590 kshitij.so 8907 
          (_etype63, _size60) = iprot.readListBegin()
8908 
          for _i64 in xrange(_size60):
8909 
            _elem65 = Item()
8910 
            _elem65.read(iprot)
8911 
            self.success.append(_elem65)
5944 mandeep.dh 8912 
          iprot.readListEnd()
8913 
        else:
8914 
          iprot.skip(ftype)
8915 
      elif fid == 1:
8916 
        if ftype == TType.STRUCT:
8917 
          self.cex = CatalogServiceException()
8918 
          self.cex.read(iprot)
8919 
        else:
8920 
          iprot.skip(ftype)
8921 
      else:
8922 
        iprot.skip(ftype)
8923 
      iprot.readFieldEnd()
8924 
    iprot.readStructEnd()
8925 
 
8926 
  def write(self, oprot):
8927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8929 
      return
8930 
    oprot.writeStructBegin('getAllItems_result')
8931 
    if self.success is not None:
8932 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8933 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8934 
      for iter66 in self.success:
8935 
        iter66.write(oprot)
5944 mandeep.dh 8936 
      oprot.writeListEnd()
8937 
      oprot.writeFieldEnd()
8938 
    if self.cex is not None:
8939 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8940 
      self.cex.write(oprot)
8941 
      oprot.writeFieldEnd()
8942 
    oprot.writeFieldStop()
8943 
    oprot.writeStructEnd()
8944 
 
8945 
  def validate(self):
8946 
    return
8947 
 
8948 
 
8949 
  def __repr__(self):
8950 
    L = ['%s=%r' % (key, value)
8951 
      for key, value in self.__dict__.iteritems()]
8952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8953 
 
8954 
  def __eq__(self, other):
8955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8956 
 
8957 
  def __ne__(self, other):
8958 
    return not (self == other)
8959 
 
8960 
class getAllItemsByStatus_args:
8961 
  """
8962 
  Attributes:
8963 
   - itemStatus
8964 
  """
8965 
 
8966 
  thrift_spec = (
8967 
    None, # 0
8968 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8969 
  )
8970 
 
8971 
  def __init__(self, itemStatus=None,):
8972 
    self.itemStatus = itemStatus
8973 
 
8974 
  def read(self, iprot):
8975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8977 
      return
8978 
    iprot.readStructBegin()
8979 
    while True:
8980 
      (fname, ftype, fid) = iprot.readFieldBegin()
8981 
      if ftype == TType.STOP:
8982 
        break
8983 
      if fid == 1:
8984 
        if ftype == TType.I32:
8985 
          self.itemStatus = iprot.readI32();
8986 
        else:
8987 
          iprot.skip(ftype)
8988 
      else:
8989 
        iprot.skip(ftype)
8990 
      iprot.readFieldEnd()
8991 
    iprot.readStructEnd()
8992 
 
8993 
  def write(self, oprot):
8994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8996 
      return
8997 
    oprot.writeStructBegin('getAllItemsByStatus_args')
8998 
    if self.itemStatus is not None:
8999 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9000 
      oprot.writeI32(self.itemStatus)
9001 
      oprot.writeFieldEnd()
9002 
    oprot.writeFieldStop()
9003 
    oprot.writeStructEnd()
9004 
 
9005 
  def validate(self):
9006 
    return
9007 
 
9008 
 
9009 
  def __repr__(self):
9010 
    L = ['%s=%r' % (key, value)
9011 
      for key, value in self.__dict__.iteritems()]
9012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9013 
 
9014 
  def __eq__(self, other):
9015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9016 
 
9017 
  def __ne__(self, other):
9018 
    return not (self == other)
9019 
 
9020 
class getAllItemsByStatus_result:
9021 
  """
9022 
  Attributes:
9023 
   - success
9024 
   - cex
9025 
  """
9026 
 
9027 
  thrift_spec = (
9028 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9029 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9030 
  )
9031 
 
9032 
  def __init__(self, success=None, cex=None,):
9033 
    self.success = success
9034 
    self.cex = cex
9035 
 
9036 
  def read(self, iprot):
9037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9039 
      return
9040 
    iprot.readStructBegin()
9041 
    while True:
9042 
      (fname, ftype, fid) = iprot.readFieldBegin()
9043 
      if ftype == TType.STOP:
9044 
        break
9045 
      if fid == 0:
9046 
        if ftype == TType.LIST:
9047 
          self.success = []
8590 kshitij.so 9048 
          (_etype70, _size67) = iprot.readListBegin()
9049 
          for _i71 in xrange(_size67):
9050 
            _elem72 = Item()
9051 
            _elem72.read(iprot)
9052 
            self.success.append(_elem72)
5944 mandeep.dh 9053 
          iprot.readListEnd()
9054 
        else:
9055 
          iprot.skip(ftype)
9056 
      elif fid == 1:
9057 
        if ftype == TType.STRUCT:
9058 
          self.cex = CatalogServiceException()
9059 
          self.cex.read(iprot)
9060 
        else:
9061 
          iprot.skip(ftype)
9062 
      else:
9063 
        iprot.skip(ftype)
9064 
      iprot.readFieldEnd()
9065 
    iprot.readStructEnd()
9066 
 
9067 
  def write(self, oprot):
9068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9070 
      return
9071 
    oprot.writeStructBegin('getAllItemsByStatus_result')
9072 
    if self.success is not None:
9073 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9074 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9075 
      for iter73 in self.success:
9076 
        iter73.write(oprot)
5944 mandeep.dh 9077 
      oprot.writeListEnd()
9078 
      oprot.writeFieldEnd()
9079 
    if self.cex is not None:
9080 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9081 
      self.cex.write(oprot)
9082 
      oprot.writeFieldEnd()
9083 
    oprot.writeFieldStop()
9084 
    oprot.writeStructEnd()
9085 
 
9086 
  def validate(self):
9087 
    return
9088 
 
9089 
 
9090 
  def __repr__(self):
9091 
    L = ['%s=%r' % (key, value)
9092 
      for key, value in self.__dict__.iteritems()]
9093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9094 
 
9095 
  def __eq__(self, other):
9096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9097 
 
9098 
  def __ne__(self, other):
9099 
    return not (self == other)
9100 
 
9101 
class markItemAsContentComplete_args:
9102 
  """
9103 
  Attributes:
9104 
   - entityId
9105 
   - category
9106 
   - brand
9107 
   - modelName
9108 
   - modelNumber
9253 rajveer 9109 
   - isAndroid
5944 mandeep.dh 9110 
  """
9111 
 
9112 
  thrift_spec = (
9113 
    None, # 0
9114 
    (1, TType.I64, 'entityId', None, None, ), # 1
9115 
    (2, TType.I64, 'category', None, None, ), # 2
9116 
    (3, TType.STRING, 'brand', None, None, ), # 3
9117 
    (4, TType.STRING, 'modelName', None, None, ), # 4
9118 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 9119 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 9120 
  )
9121 
 
9253 rajveer 9122 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 9123 
    self.entityId = entityId
9124 
    self.category = category
9125 
    self.brand = brand
9126 
    self.modelName = modelName
9127 
    self.modelNumber = modelNumber
9253 rajveer 9128 
    self.isAndroid = isAndroid
5944 mandeep.dh 9129 
 
9130 
  def read(self, iprot):
9131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9133 
      return
9134 
    iprot.readStructBegin()
9135 
    while True:
9136 
      (fname, ftype, fid) = iprot.readFieldBegin()
9137 
      if ftype == TType.STOP:
9138 
        break
9139 
      if fid == 1:
9140 
        if ftype == TType.I64:
9141 
          self.entityId = iprot.readI64();
9142 
        else:
9143 
          iprot.skip(ftype)
9144 
      elif fid == 2:
9145 
        if ftype == TType.I64:
9146 
          self.category = iprot.readI64();
9147 
        else:
9148 
          iprot.skip(ftype)
9149 
      elif fid == 3:
9150 
        if ftype == TType.STRING:
9151 
          self.brand = iprot.readString();
9152 
        else:
9153 
          iprot.skip(ftype)
9154 
      elif fid == 4:
9155 
        if ftype == TType.STRING:
9156 
          self.modelName = iprot.readString();
9157 
        else:
9158 
          iprot.skip(ftype)
9159 
      elif fid == 5:
9160 
        if ftype == TType.STRING:
9161 
          self.modelNumber = iprot.readString();
9162 
        else:
9163 
          iprot.skip(ftype)
9253 rajveer 9164 
      elif fid == 6:
9165 
        if ftype == TType.BOOL:
9166 
          self.isAndroid = iprot.readBool();
9167 
        else:
9168 
          iprot.skip(ftype)
5944 mandeep.dh 9169 
      else:
9170 
        iprot.skip(ftype)
9171 
      iprot.readFieldEnd()
9172 
    iprot.readStructEnd()
9173 
 
9174 
  def write(self, oprot):
9175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9177 
      return
9178 
    oprot.writeStructBegin('markItemAsContentComplete_args')
9179 
    if self.entityId is not None:
9180 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
9181 
      oprot.writeI64(self.entityId)
9182 
      oprot.writeFieldEnd()
9183 
    if self.category is not None:
9184 
      oprot.writeFieldBegin('category', TType.I64, 2)
9185 
      oprot.writeI64(self.category)
9186 
      oprot.writeFieldEnd()
9187 
    if self.brand is not None:
9188 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9189 
      oprot.writeString(self.brand)
9190 
      oprot.writeFieldEnd()
9191 
    if self.modelName is not None:
9192 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
9193 
      oprot.writeString(self.modelName)
9194 
      oprot.writeFieldEnd()
9195 
    if self.modelNumber is not None:
9196 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
9197 
      oprot.writeString(self.modelNumber)
9198 
      oprot.writeFieldEnd()
9253 rajveer 9199 
    if self.isAndroid is not None:
9200 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
9201 
      oprot.writeBool(self.isAndroid)
9202 
      oprot.writeFieldEnd()
5944 mandeep.dh 9203 
    oprot.writeFieldStop()
9204 
    oprot.writeStructEnd()
9205 
 
9206 
  def validate(self):
9207 
    return
9208 
 
9209 
 
9210 
  def __repr__(self):
9211 
    L = ['%s=%r' % (key, value)
9212 
      for key, value in self.__dict__.iteritems()]
9213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9214 
 
9215 
  def __eq__(self, other):
9216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9217 
 
9218 
  def __ne__(self, other):
9219 
    return not (self == other)
9220 
 
9221 
class markItemAsContentComplete_result:
9222 
  """
9223 
  Attributes:
9224 
   - success
9225 
   - cex
9226 
  """
9227 
 
9228 
  thrift_spec = (
9229 
    (0, TType.BOOL, 'success', None, None, ), # 0
9230 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9231 
  )
9232 
 
9233 
  def __init__(self, success=None, cex=None,):
9234 
    self.success = success
9235 
    self.cex = cex
9236 
 
9237 
  def read(self, iprot):
9238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9240 
      return
9241 
    iprot.readStructBegin()
9242 
    while True:
9243 
      (fname, ftype, fid) = iprot.readFieldBegin()
9244 
      if ftype == TType.STOP:
9245 
        break
9246 
      if fid == 0:
9247 
        if ftype == TType.BOOL:
9248 
          self.success = iprot.readBool();
9249 
        else:
9250 
          iprot.skip(ftype)
9251 
      elif fid == 1:
9252 
        if ftype == TType.STRUCT:
9253 
          self.cex = CatalogServiceException()
9254 
          self.cex.read(iprot)
9255 
        else:
9256 
          iprot.skip(ftype)
9257 
      else:
9258 
        iprot.skip(ftype)
9259 
      iprot.readFieldEnd()
9260 
    iprot.readStructEnd()
9261 
 
9262 
  def write(self, oprot):
9263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9265 
      return
9266 
    oprot.writeStructBegin('markItemAsContentComplete_result')
9267 
    if self.success is not None:
9268 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9269 
      oprot.writeBool(self.success)
9270 
      oprot.writeFieldEnd()
9271 
    if self.cex is not None:
9272 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9273 
      self.cex.write(oprot)
9274 
      oprot.writeFieldEnd()
9275 
    oprot.writeFieldStop()
9276 
    oprot.writeStructEnd()
9277 
 
9278 
  def validate(self):
9279 
    return
9280 
 
9281 
 
9282 
  def __repr__(self):
9283 
    L = ['%s=%r' % (key, value)
9284 
      for key, value in self.__dict__.iteritems()]
9285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9286 
 
9287 
  def __eq__(self, other):
9288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9289 
 
9290 
  def __ne__(self, other):
9291 
    return not (self == other)
9292 
 
9293 
class getAllItemsInRange_args:
9294 
  """
9295 
  Attributes:
9296 
   - offset
9297 
   - limit
9298 
  """
9299 
 
9300 
  thrift_spec = (
9301 
    None, # 0
9302 
    (1, TType.I64, 'offset', None, None, ), # 1
9303 
    (2, TType.I64, 'limit', None, None, ), # 2
9304 
  )
9305 
 
9306 
  def __init__(self, offset=None, limit=None,):
9307 
    self.offset = offset
9308 
    self.limit = limit
9309 
 
9310 
  def read(self, iprot):
9311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9313 
      return
9314 
    iprot.readStructBegin()
9315 
    while True:
9316 
      (fname, ftype, fid) = iprot.readFieldBegin()
9317 
      if ftype == TType.STOP:
9318 
        break
9319 
      if fid == 1:
9320 
        if ftype == TType.I64:
9321 
          self.offset = iprot.readI64();
9322 
        else:
9323 
          iprot.skip(ftype)
9324 
      elif fid == 2:
9325 
        if ftype == TType.I64:
9326 
          self.limit = iprot.readI64();
9327 
        else:
9328 
          iprot.skip(ftype)
9329 
      else:
9330 
        iprot.skip(ftype)
9331 
      iprot.readFieldEnd()
9332 
    iprot.readStructEnd()
9333 
 
9334 
  def write(self, oprot):
9335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9337 
      return
9338 
    oprot.writeStructBegin('getAllItemsInRange_args')
9339 
    if self.offset is not None:
9340 
      oprot.writeFieldBegin('offset', TType.I64, 1)
9341 
      oprot.writeI64(self.offset)
9342 
      oprot.writeFieldEnd()
9343 
    if self.limit is not None:
9344 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9345 
      oprot.writeI64(self.limit)
9346 
      oprot.writeFieldEnd()
9347 
    oprot.writeFieldStop()
9348 
    oprot.writeStructEnd()
9349 
 
9350 
  def validate(self):
9351 
    return
9352 
 
9353 
 
9354 
  def __repr__(self):
9355 
    L = ['%s=%r' % (key, value)
9356 
      for key, value in self.__dict__.iteritems()]
9357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9358 
 
9359 
  def __eq__(self, other):
9360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9361 
 
9362 
  def __ne__(self, other):
9363 
    return not (self == other)
9364 
 
9365 
class getAllItemsInRange_result:
9366 
  """
9367 
  Attributes:
9368 
   - success
9369 
   - cex
9370 
  """
9371 
 
9372 
  thrift_spec = (
9373 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9374 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9375 
  )
9376 
 
9377 
  def __init__(self, success=None, cex=None,):
9378 
    self.success = success
9379 
    self.cex = cex
9380 
 
9381 
  def read(self, iprot):
9382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9384 
      return
9385 
    iprot.readStructBegin()
9386 
    while True:
9387 
      (fname, ftype, fid) = iprot.readFieldBegin()
9388 
      if ftype == TType.STOP:
9389 
        break
9390 
      if fid == 0:
9391 
        if ftype == TType.LIST:
9392 
          self.success = []
8590 kshitij.so 9393 
          (_etype77, _size74) = iprot.readListBegin()
9394 
          for _i78 in xrange(_size74):
9395 
            _elem79 = Item()
9396 
            _elem79.read(iprot)
9397 
            self.success.append(_elem79)
5944 mandeep.dh 9398 
          iprot.readListEnd()
9399 
        else:
9400 
          iprot.skip(ftype)
9401 
      elif fid == 1:
9402 
        if ftype == TType.STRUCT:
9403 
          self.cex = CatalogServiceException()
9404 
          self.cex.read(iprot)
9405 
        else:
9406 
          iprot.skip(ftype)
9407 
      else:
9408 
        iprot.skip(ftype)
9409 
      iprot.readFieldEnd()
9410 
    iprot.readStructEnd()
9411 
 
9412 
  def write(self, oprot):
9413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9415 
      return
9416 
    oprot.writeStructBegin('getAllItemsInRange_result')
9417 
    if self.success is not None:
9418 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9419 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9420 
      for iter80 in self.success:
9421 
        iter80.write(oprot)
5944 mandeep.dh 9422 
      oprot.writeListEnd()
9423 
      oprot.writeFieldEnd()
9424 
    if self.cex is not None:
9425 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9426 
      self.cex.write(oprot)
9427 
      oprot.writeFieldEnd()
9428 
    oprot.writeFieldStop()
9429 
    oprot.writeStructEnd()
9430 
 
9431 
  def validate(self):
9432 
    return
9433 
 
9434 
 
9435 
  def __repr__(self):
9436 
    L = ['%s=%r' % (key, value)
9437 
      for key, value in self.__dict__.iteritems()]
9438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9439 
 
9440 
  def __eq__(self, other):
9441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9442 
 
9443 
  def __ne__(self, other):
9444 
    return not (self == other)
9445 
 
9446 
class getAllItemsByStatusInRange_args:
9447 
  """
9448 
  Attributes:
9449 
   - itemStatus
9450 
   - offset
9451 
   - limit
9452 
  """
9453 
 
9454 
  thrift_spec = (
9455 
    None, # 0
9456 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9457 
    (2, TType.I64, 'offset', None, None, ), # 2
9458 
    (3, TType.I64, 'limit', None, None, ), # 3
9459 
  )
9460 
 
9461 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
9462 
    self.itemStatus = itemStatus
9463 
    self.offset = offset
9464 
    self.limit = limit
9465 
 
9466 
  def read(self, iprot):
9467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9469 
      return
9470 
    iprot.readStructBegin()
9471 
    while True:
9472 
      (fname, ftype, fid) = iprot.readFieldBegin()
9473 
      if ftype == TType.STOP:
9474 
        break
9475 
      if fid == 1:
9476 
        if ftype == TType.I32:
9477 
          self.itemStatus = iprot.readI32();
9478 
        else:
9479 
          iprot.skip(ftype)
9480 
      elif fid == 2:
9481 
        if ftype == TType.I64:
9482 
          self.offset = iprot.readI64();
9483 
        else:
9484 
          iprot.skip(ftype)
9485 
      elif fid == 3:
9486 
        if ftype == TType.I64:
9487 
          self.limit = iprot.readI64();
9488 
        else:
9489 
          iprot.skip(ftype)
9490 
      else:
9491 
        iprot.skip(ftype)
9492 
      iprot.readFieldEnd()
9493 
    iprot.readStructEnd()
9494 
 
9495 
  def write(self, oprot):
9496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9498 
      return
9499 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
9500 
    if self.itemStatus is not None:
9501 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9502 
      oprot.writeI32(self.itemStatus)
9503 
      oprot.writeFieldEnd()
9504 
    if self.offset is not None:
9505 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9506 
      oprot.writeI64(self.offset)
9507 
      oprot.writeFieldEnd()
9508 
    if self.limit is not None:
9509 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9510 
      oprot.writeI64(self.limit)
9511 
      oprot.writeFieldEnd()
9512 
    oprot.writeFieldStop()
9513 
    oprot.writeStructEnd()
9514 
 
9515 
  def validate(self):
9516 
    return
9517 
 
9518 
 
9519 
  def __repr__(self):
9520 
    L = ['%s=%r' % (key, value)
9521 
      for key, value in self.__dict__.iteritems()]
9522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9523 
 
9524 
  def __eq__(self, other):
9525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9526 
 
9527 
  def __ne__(self, other):
9528 
    return not (self == other)
9529 
 
9530 
class getAllItemsByStatusInRange_result:
9531 
  """
9532 
  Attributes:
9533 
   - success
9534 
   - cex
9535 
  """
9536 
 
9537 
  thrift_spec = (
9538 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9539 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9540 
  )
9541 
 
9542 
  def __init__(self, success=None, cex=None,):
9543 
    self.success = success
9544 
    self.cex = cex
9545 
 
9546 
  def read(self, iprot):
9547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9549 
      return
9550 
    iprot.readStructBegin()
9551 
    while True:
9552 
      (fname, ftype, fid) = iprot.readFieldBegin()
9553 
      if ftype == TType.STOP:
9554 
        break
9555 
      if fid == 0:
9556 
        if ftype == TType.LIST:
9557 
          self.success = []
8590 kshitij.so 9558 
          (_etype84, _size81) = iprot.readListBegin()
9559 
          for _i85 in xrange(_size81):
9560 
            _elem86 = Item()
9561 
            _elem86.read(iprot)
9562 
            self.success.append(_elem86)
5944 mandeep.dh 9563 
          iprot.readListEnd()
9564 
        else:
9565 
          iprot.skip(ftype)
9566 
      elif fid == 1:
9567 
        if ftype == TType.STRUCT:
9568 
          self.cex = CatalogServiceException()
9569 
          self.cex.read(iprot)
9570 
        else:
9571 
          iprot.skip(ftype)
9572 
      else:
9573 
        iprot.skip(ftype)
9574 
      iprot.readFieldEnd()
9575 
    iprot.readStructEnd()
9576 
 
9577 
  def write(self, oprot):
9578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9580 
      return
9581 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
9582 
    if self.success is not None:
9583 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9584 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9585 
      for iter87 in self.success:
9586 
        iter87.write(oprot)
5944 mandeep.dh 9587 
      oprot.writeListEnd()
9588 
      oprot.writeFieldEnd()
9589 
    if self.cex is not None:
9590 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9591 
      self.cex.write(oprot)
9592 
      oprot.writeFieldEnd()
9593 
    oprot.writeFieldStop()
9594 
    oprot.writeStructEnd()
9595 
 
9596 
  def validate(self):
9597 
    return
9598 
 
9599 
 
9600 
  def __repr__(self):
9601 
    L = ['%s=%r' % (key, value)
9602 
      for key, value in self.__dict__.iteritems()]
9603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9604 
 
9605 
  def __eq__(self, other):
9606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9607 
 
9608 
  def __ne__(self, other):
9609 
    return not (self == other)
9610 
 
9611 
class getItemCountByStatus_args:
9612 
  """
9613 
  Attributes:
9614 
   - useStatus
9615 
   - itemStatus
9616 
  """
9617 
 
9618 
  thrift_spec = (
9619 
    None, # 0
9620 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
9621 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
9622 
  )
9623 
 
9624 
  def __init__(self, useStatus=None, itemStatus=None,):
9625 
    self.useStatus = useStatus
9626 
    self.itemStatus = itemStatus
9627 
 
9628 
  def read(self, iprot):
9629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9631 
      return
9632 
    iprot.readStructBegin()
9633 
    while True:
9634 
      (fname, ftype, fid) = iprot.readFieldBegin()
9635 
      if ftype == TType.STOP:
9636 
        break
9637 
      if fid == 1:
9638 
        if ftype == TType.BOOL:
9639 
          self.useStatus = iprot.readBool();
9640 
        else:
9641 
          iprot.skip(ftype)
9642 
      elif fid == 2:
9643 
        if ftype == TType.I32:
9644 
          self.itemStatus = iprot.readI32();
9645 
        else:
9646 
          iprot.skip(ftype)
9647 
      else:
9648 
        iprot.skip(ftype)
9649 
      iprot.readFieldEnd()
9650 
    iprot.readStructEnd()
9651 
 
9652 
  def write(self, oprot):
9653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9655 
      return
9656 
    oprot.writeStructBegin('getItemCountByStatus_args')
9657 
    if self.useStatus is not None:
9658 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
9659 
      oprot.writeBool(self.useStatus)
9660 
      oprot.writeFieldEnd()
9661 
    if self.itemStatus is not None:
9662 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
9663 
      oprot.writeI32(self.itemStatus)
9664 
      oprot.writeFieldEnd()
9665 
    oprot.writeFieldStop()
9666 
    oprot.writeStructEnd()
9667 
 
9668 
  def validate(self):
9669 
    return
9670 
 
9671 
 
9672 
  def __repr__(self):
9673 
    L = ['%s=%r' % (key, value)
9674 
      for key, value in self.__dict__.iteritems()]
9675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9676 
 
9677 
  def __eq__(self, other):
9678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9679 
 
9680 
  def __ne__(self, other):
9681 
    return not (self == other)
9682 
 
9683 
class getItemCountByStatus_result:
9684 
  """
9685 
  Attributes:
9686 
   - success
9687 
  """
9688 
 
9689 
  thrift_spec = (
9690 
    (0, TType.I32, 'success', None, None, ), # 0
9691 
  )
9692 
 
9693 
  def __init__(self, success=None,):
9694 
    self.success = success
9695 
 
9696 
  def read(self, iprot):
9697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9699 
      return
9700 
    iprot.readStructBegin()
9701 
    while True:
9702 
      (fname, ftype, fid) = iprot.readFieldBegin()
9703 
      if ftype == TType.STOP:
9704 
        break
9705 
      if fid == 0:
9706 
        if ftype == TType.I32:
9707 
          self.success = iprot.readI32();
9708 
        else:
9709 
          iprot.skip(ftype)
9710 
      else:
9711 
        iprot.skip(ftype)
9712 
      iprot.readFieldEnd()
9713 
    iprot.readStructEnd()
9714 
 
9715 
  def write(self, oprot):
9716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9718 
      return
9719 
    oprot.writeStructBegin('getItemCountByStatus_result')
9720 
    if self.success is not None:
9721 
      oprot.writeFieldBegin('success', TType.I32, 0)
9722 
      oprot.writeI32(self.success)
9723 
      oprot.writeFieldEnd()
9724 
    oprot.writeFieldStop()
9725 
    oprot.writeStructEnd()
9726 
 
9727 
  def validate(self):
9728 
    return
9729 
 
9730 
 
9731 
  def __repr__(self):
9732 
    L = ['%s=%r' % (key, value)
9733 
      for key, value in self.__dict__.iteritems()]
9734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9735 
 
9736 
  def __eq__(self, other):
9737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9738 
 
9739 
  def __ne__(self, other):
9740 
    return not (self == other)
9741 
 
9742 
class getBestSellers_args:
9743 
 
9744 
  thrift_spec = (
9745 
  )
9746 
 
9747 
  def read(self, iprot):
9748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9750 
      return
9751 
    iprot.readStructBegin()
9752 
    while True:
9753 
      (fname, ftype, fid) = iprot.readFieldBegin()
9754 
      if ftype == TType.STOP:
9755 
        break
9756 
      else:
9757 
        iprot.skip(ftype)
9758 
      iprot.readFieldEnd()
9759 
    iprot.readStructEnd()
9760 
 
9761 
  def write(self, oprot):
9762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9764 
      return
9765 
    oprot.writeStructBegin('getBestSellers_args')
9766 
    oprot.writeFieldStop()
9767 
    oprot.writeStructEnd()
9768 
 
9769 
  def validate(self):
9770 
    return
9771 
 
9772 
 
9773 
  def __repr__(self):
9774 
    L = ['%s=%r' % (key, value)
9775 
      for key, value in self.__dict__.iteritems()]
9776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9777 
 
9778 
  def __eq__(self, other):
9779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9780 
 
9781 
  def __ne__(self, other):
9782 
    return not (self == other)
9783 
 
9784 
class getBestSellers_result:
9785 
  """
9786 
  Attributes:
9787 
   - success
9788 
   - isex
9789 
  """
9790 
 
9791 
  thrift_spec = (
9792 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9793 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9794 
  )
9795 
 
9796 
  def __init__(self, success=None, isex=None,):
9797 
    self.success = success
9798 
    self.isex = isex
9799 
 
9800 
  def read(self, iprot):
9801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9803 
      return
9804 
    iprot.readStructBegin()
9805 
    while True:
9806 
      (fname, ftype, fid) = iprot.readFieldBegin()
9807 
      if ftype == TType.STOP:
9808 
        break
9809 
      if fid == 0:
9810 
        if ftype == TType.LIST:
9811 
          self.success = []
8590 kshitij.so 9812 
          (_etype91, _size88) = iprot.readListBegin()
9813 
          for _i92 in xrange(_size88):
9814 
            _elem93 = Item()
9815 
            _elem93.read(iprot)
9816 
            self.success.append(_elem93)
5944 mandeep.dh 9817 
          iprot.readListEnd()
9818 
        else:
9819 
          iprot.skip(ftype)
9820 
      elif fid == 1:
9821 
        if ftype == TType.STRUCT:
9822 
          self.isex = CatalogServiceException()
9823 
          self.isex.read(iprot)
9824 
        else:
9825 
          iprot.skip(ftype)
9826 
      else:
9827 
        iprot.skip(ftype)
9828 
      iprot.readFieldEnd()
9829 
    iprot.readStructEnd()
9830 
 
9831 
  def write(self, oprot):
9832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9834 
      return
9835 
    oprot.writeStructBegin('getBestSellers_result')
9836 
    if self.success is not None:
9837 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9838 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9839 
      for iter94 in self.success:
9840 
        iter94.write(oprot)
5944 mandeep.dh 9841 
      oprot.writeListEnd()
9842 
      oprot.writeFieldEnd()
9843 
    if self.isex is not None:
9844 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9845 
      self.isex.write(oprot)
9846 
      oprot.writeFieldEnd()
9847 
    oprot.writeFieldStop()
9848 
    oprot.writeStructEnd()
9849 
 
9850 
  def validate(self):
9851 
    return
9852 
 
9853 
 
9854 
  def __repr__(self):
9855 
    L = ['%s=%r' % (key, value)
9856 
      for key, value in self.__dict__.iteritems()]
9857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9858 
 
9859 
  def __eq__(self, other):
9860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9861 
 
9862 
  def __ne__(self, other):
9863 
    return not (self == other)
9864 
 
9865 
class getBestSellersCatalogIds_args:
9866 
  """
9867 
  Attributes:
9868 
   - beginIndex
9869 
   - totalItems
9870 
   - brand
9871 
   - category
9872 
  """
9873 
 
9874 
  thrift_spec = (
9875 
    None, # 0
9876 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9877 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9878 
    (3, TType.STRING, 'brand', None, None, ), # 3
9879 
    (4, TType.I64, 'category', None, None, ), # 4
9880 
  )
9881 
 
9882 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9883 
    self.beginIndex = beginIndex
9884 
    self.totalItems = totalItems
9885 
    self.brand = brand
9886 
    self.category = category
9887 
 
9888 
  def read(self, iprot):
9889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9891 
      return
9892 
    iprot.readStructBegin()
9893 
    while True:
9894 
      (fname, ftype, fid) = iprot.readFieldBegin()
9895 
      if ftype == TType.STOP:
9896 
        break
9897 
      if fid == 1:
9898 
        if ftype == TType.I64:
9899 
          self.beginIndex = iprot.readI64();
9900 
        else:
9901 
          iprot.skip(ftype)
9902 
      elif fid == 2:
9903 
        if ftype == TType.I64:
9904 
          self.totalItems = iprot.readI64();
9905 
        else:
9906 
          iprot.skip(ftype)
9907 
      elif fid == 3:
9908 
        if ftype == TType.STRING:
9909 
          self.brand = iprot.readString();
9910 
        else:
9911 
          iprot.skip(ftype)
9912 
      elif fid == 4:
9913 
        if ftype == TType.I64:
9914 
          self.category = iprot.readI64();
9915 
        else:
9916 
          iprot.skip(ftype)
9917 
      else:
9918 
        iprot.skip(ftype)
9919 
      iprot.readFieldEnd()
9920 
    iprot.readStructEnd()
9921 
 
9922 
  def write(self, oprot):
9923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9925 
      return
9926 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
9927 
    if self.beginIndex is not None:
9928 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9929 
      oprot.writeI64(self.beginIndex)
9930 
      oprot.writeFieldEnd()
9931 
    if self.totalItems is not None:
9932 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9933 
      oprot.writeI64(self.totalItems)
9934 
      oprot.writeFieldEnd()
9935 
    if self.brand is not None:
9936 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9937 
      oprot.writeString(self.brand)
9938 
      oprot.writeFieldEnd()
9939 
    if self.category is not None:
9940 
      oprot.writeFieldBegin('category', TType.I64, 4)
9941 
      oprot.writeI64(self.category)
9942 
      oprot.writeFieldEnd()
9943 
    oprot.writeFieldStop()
9944 
    oprot.writeStructEnd()
9945 
 
9946 
  def validate(self):
9947 
    return
9948 
 
9949 
 
9950 
  def __repr__(self):
9951 
    L = ['%s=%r' % (key, value)
9952 
      for key, value in self.__dict__.iteritems()]
9953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9954 
 
9955 
  def __eq__(self, other):
9956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9957 
 
9958 
  def __ne__(self, other):
9959 
    return not (self == other)
9960 
 
9961 
class getBestSellersCatalogIds_result:
9962 
  """
9963 
  Attributes:
9964 
   - success
9965 
   - cex
9966 
  """
9967 
 
9968 
  thrift_spec = (
9969 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9970 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9971 
  )
9972 
 
9973 
  def __init__(self, success=None, cex=None,):
9974 
    self.success = success
9975 
    self.cex = cex
9976 
 
9977 
  def read(self, iprot):
9978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9980 
      return
9981 
    iprot.readStructBegin()
9982 
    while True:
9983 
      (fname, ftype, fid) = iprot.readFieldBegin()
9984 
      if ftype == TType.STOP:
9985 
        break
9986 
      if fid == 0:
9987 
        if ftype == TType.LIST:
9988 
          self.success = []
8590 kshitij.so 9989 
          (_etype98, _size95) = iprot.readListBegin()
9990 
          for _i99 in xrange(_size95):
9991 
            _elem100 = iprot.readI64();
9992 
            self.success.append(_elem100)
5944 mandeep.dh 9993 
          iprot.readListEnd()
9994 
        else:
9995 
          iprot.skip(ftype)
9996 
      elif fid == 1:
9997 
        if ftype == TType.STRUCT:
9998 
          self.cex = CatalogServiceException()
9999 
          self.cex.read(iprot)
10000 
        else:
10001 
          iprot.skip(ftype)
10002 
      else:
10003 
        iprot.skip(ftype)
10004 
      iprot.readFieldEnd()
10005 
    iprot.readStructEnd()
10006 
 
10007 
  def write(self, oprot):
10008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10010 
      return
10011 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
10012 
    if self.success is not None:
10013 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10014 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10015 
      for iter101 in self.success:
10016 
        oprot.writeI64(iter101)
5944 mandeep.dh 10017 
      oprot.writeListEnd()
10018 
      oprot.writeFieldEnd()
10019 
    if self.cex is not None:
10020 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10021 
      self.cex.write(oprot)
10022 
      oprot.writeFieldEnd()
10023 
    oprot.writeFieldStop()
10024 
    oprot.writeStructEnd()
10025 
 
10026 
  def validate(self):
10027 
    return
10028 
 
10029 
 
10030 
  def __repr__(self):
10031 
    L = ['%s=%r' % (key, value)
10032 
      for key, value in self.__dict__.iteritems()]
10033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10034 
 
10035 
  def __eq__(self, other):
10036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10037 
 
10038 
  def __ne__(self, other):
10039 
    return not (self == other)
10040 
 
10041 
class getBestSellersCount_args:
10042 
 
10043 
  thrift_spec = (
10044 
  )
10045 
 
10046 
  def read(self, iprot):
10047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10049 
      return
10050 
    iprot.readStructBegin()
10051 
    while True:
10052 
      (fname, ftype, fid) = iprot.readFieldBegin()
10053 
      if ftype == TType.STOP:
10054 
        break
10055 
      else:
10056 
        iprot.skip(ftype)
10057 
      iprot.readFieldEnd()
10058 
    iprot.readStructEnd()
10059 
 
10060 
  def write(self, oprot):
10061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10063 
      return
10064 
    oprot.writeStructBegin('getBestSellersCount_args')
10065 
    oprot.writeFieldStop()
10066 
    oprot.writeStructEnd()
10067 
 
10068 
  def validate(self):
10069 
    return
10070 
 
10071 
 
10072 
  def __repr__(self):
10073 
    L = ['%s=%r' % (key, value)
10074 
      for key, value in self.__dict__.iteritems()]
10075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10076 
 
10077 
  def __eq__(self, other):
10078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10079 
 
10080 
  def __ne__(self, other):
10081 
    return not (self == other)
10082 
 
10083 
class getBestSellersCount_result:
10084 
  """
10085 
  Attributes:
10086 
   - success
10087 
   - cex
10088 
  """
10089 
 
10090 
  thrift_spec = (
10091 
    (0, TType.I64, 'success', None, None, ), # 0
10092 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10093 
  )
10094 
 
10095 
  def __init__(self, success=None, cex=None,):
10096 
    self.success = success
10097 
    self.cex = cex
10098 
 
10099 
  def read(self, iprot):
10100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10102 
      return
10103 
    iprot.readStructBegin()
10104 
    while True:
10105 
      (fname, ftype, fid) = iprot.readFieldBegin()
10106 
      if ftype == TType.STOP:
10107 
        break
10108 
      if fid == 0:
10109 
        if ftype == TType.I64:
10110 
          self.success = iprot.readI64();
10111 
        else:
10112 
          iprot.skip(ftype)
10113 
      elif fid == 1:
10114 
        if ftype == TType.STRUCT:
10115 
          self.cex = CatalogServiceException()
10116 
          self.cex.read(iprot)
10117 
        else:
10118 
          iprot.skip(ftype)
10119 
      else:
10120 
        iprot.skip(ftype)
10121 
      iprot.readFieldEnd()
10122 
    iprot.readStructEnd()
10123 
 
10124 
  def write(self, oprot):
10125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10127 
      return
10128 
    oprot.writeStructBegin('getBestSellersCount_result')
10129 
    if self.success is not None:
10130 
      oprot.writeFieldBegin('success', TType.I64, 0)
10131 
      oprot.writeI64(self.success)
10132 
      oprot.writeFieldEnd()
10133 
    if self.cex is not None:
10134 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10135 
      self.cex.write(oprot)
10136 
      oprot.writeFieldEnd()
10137 
    oprot.writeFieldStop()
10138 
    oprot.writeStructEnd()
10139 
 
10140 
  def validate(self):
10141 
    return
10142 
 
10143 
 
10144 
  def __repr__(self):
10145 
    L = ['%s=%r' % (key, value)
10146 
      for key, value in self.__dict__.iteritems()]
10147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10148 
 
10149 
  def __eq__(self, other):
10150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10151 
 
10152 
  def __ne__(self, other):
10153 
    return not (self == other)
10154 
 
10155 
class getBestDeals_args:
10156 
 
10157 
  thrift_spec = (
10158 
  )
10159 
 
10160 
  def read(self, iprot):
10161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10163 
      return
10164 
    iprot.readStructBegin()
10165 
    while True:
10166 
      (fname, ftype, fid) = iprot.readFieldBegin()
10167 
      if ftype == TType.STOP:
10168 
        break
10169 
      else:
10170 
        iprot.skip(ftype)
10171 
      iprot.readFieldEnd()
10172 
    iprot.readStructEnd()
10173 
 
10174 
  def write(self, oprot):
10175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10177 
      return
10178 
    oprot.writeStructBegin('getBestDeals_args')
10179 
    oprot.writeFieldStop()
10180 
    oprot.writeStructEnd()
10181 
 
10182 
  def validate(self):
10183 
    return
10184 
 
10185 
 
10186 
  def __repr__(self):
10187 
    L = ['%s=%r' % (key, value)
10188 
      for key, value in self.__dict__.iteritems()]
10189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10190 
 
10191 
  def __eq__(self, other):
10192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10193 
 
10194 
  def __ne__(self, other):
10195 
    return not (self == other)
10196 
 
10197 
class getBestDeals_result:
10198 
  """
10199 
  Attributes:
10200 
   - success
10201 
   - isex
10202 
  """
10203 
 
10204 
  thrift_spec = (
10205 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10206 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10207 
  )
10208 
 
10209 
  def __init__(self, success=None, isex=None,):
10210 
    self.success = success
10211 
    self.isex = isex
10212 
 
10213 
  def read(self, iprot):
10214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10216 
      return
10217 
    iprot.readStructBegin()
10218 
    while True:
10219 
      (fname, ftype, fid) = iprot.readFieldBegin()
10220 
      if ftype == TType.STOP:
10221 
        break
10222 
      if fid == 0:
10223 
        if ftype == TType.LIST:
10224 
          self.success = []
8590 kshitij.so 10225 
          (_etype105, _size102) = iprot.readListBegin()
10226 
          for _i106 in xrange(_size102):
10227 
            _elem107 = Item()
10228 
            _elem107.read(iprot)
10229 
            self.success.append(_elem107)
5944 mandeep.dh 10230 
          iprot.readListEnd()
10231 
        else:
10232 
          iprot.skip(ftype)
10233 
      elif fid == 1:
10234 
        if ftype == TType.STRUCT:
10235 
          self.isex = CatalogServiceException()
10236 
          self.isex.read(iprot)
10237 
        else:
10238 
          iprot.skip(ftype)
10239 
      else:
10240 
        iprot.skip(ftype)
10241 
      iprot.readFieldEnd()
10242 
    iprot.readStructEnd()
10243 
 
10244 
  def write(self, oprot):
10245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10247 
      return
10248 
    oprot.writeStructBegin('getBestDeals_result')
10249 
    if self.success is not None:
10250 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10251 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10252 
      for iter108 in self.success:
10253 
        iter108.write(oprot)
5944 mandeep.dh 10254 
      oprot.writeListEnd()
10255 
      oprot.writeFieldEnd()
10256 
    if self.isex is not None:
10257 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10258 
      self.isex.write(oprot)
10259 
      oprot.writeFieldEnd()
10260 
    oprot.writeFieldStop()
10261 
    oprot.writeStructEnd()
10262 
 
10263 
  def validate(self):
10264 
    return
10265 
 
10266 
 
10267 
  def __repr__(self):
10268 
    L = ['%s=%r' % (key, value)
10269 
      for key, value in self.__dict__.iteritems()]
10270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10271 
 
10272 
  def __eq__(self, other):
10273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10274 
 
10275 
  def __ne__(self, other):
10276 
    return not (self == other)
10277 
 
10278 
class getBestDealsCatalogIds_args:
10279 
  """
10280 
  Attributes:
10281 
   - beginIndex
10282 
   - totalItems
10283 
   - brand
10284 
   - category
10285 
  """
10286 
 
10287 
  thrift_spec = (
10288 
    None, # 0
10289 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10290 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10291 
    (3, TType.STRING, 'brand', None, None, ), # 3
10292 
    (4, TType.I64, 'category', None, None, ), # 4
10293 
  )
10294 
 
10295 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10296 
    self.beginIndex = beginIndex
10297 
    self.totalItems = totalItems
10298 
    self.brand = brand
10299 
    self.category = category
10300 
 
10301 
  def read(self, iprot):
10302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10304 
      return
10305 
    iprot.readStructBegin()
10306 
    while True:
10307 
      (fname, ftype, fid) = iprot.readFieldBegin()
10308 
      if ftype == TType.STOP:
10309 
        break
10310 
      if fid == 1:
10311 
        if ftype == TType.I64:
10312 
          self.beginIndex = iprot.readI64();
10313 
        else:
10314 
          iprot.skip(ftype)
10315 
      elif fid == 2:
10316 
        if ftype == TType.I64:
10317 
          self.totalItems = iprot.readI64();
10318 
        else:
10319 
          iprot.skip(ftype)
10320 
      elif fid == 3:
10321 
        if ftype == TType.STRING:
10322 
          self.brand = iprot.readString();
10323 
        else:
10324 
          iprot.skip(ftype)
10325 
      elif fid == 4:
10326 
        if ftype == TType.I64:
10327 
          self.category = iprot.readI64();
10328 
        else:
10329 
          iprot.skip(ftype)
10330 
      else:
10331 
        iprot.skip(ftype)
10332 
      iprot.readFieldEnd()
10333 
    iprot.readStructEnd()
10334 
 
10335 
  def write(self, oprot):
10336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10338 
      return
10339 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
10340 
    if self.beginIndex is not None:
10341 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10342 
      oprot.writeI64(self.beginIndex)
10343 
      oprot.writeFieldEnd()
10344 
    if self.totalItems is not None:
10345 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10346 
      oprot.writeI64(self.totalItems)
10347 
      oprot.writeFieldEnd()
10348 
    if self.brand is not None:
10349 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10350 
      oprot.writeString(self.brand)
10351 
      oprot.writeFieldEnd()
10352 
    if self.category is not None:
10353 
      oprot.writeFieldBegin('category', TType.I64, 4)
10354 
      oprot.writeI64(self.category)
10355 
      oprot.writeFieldEnd()
10356 
    oprot.writeFieldStop()
10357 
    oprot.writeStructEnd()
10358 
 
10359 
  def validate(self):
10360 
    return
10361 
 
10362 
 
10363 
  def __repr__(self):
10364 
    L = ['%s=%r' % (key, value)
10365 
      for key, value in self.__dict__.iteritems()]
10366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10367 
 
10368 
  def __eq__(self, other):
10369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10370 
 
10371 
  def __ne__(self, other):
10372 
    return not (self == other)
10373 
 
10374 
class getBestDealsCatalogIds_result:
10375 
  """
10376 
  Attributes:
10377 
   - success
10378 
   - cex
10379 
  """
10380 
 
10381 
  thrift_spec = (
10382 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10383 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10384 
  )
10385 
 
10386 
  def __init__(self, success=None, cex=None,):
10387 
    self.success = success
10388 
    self.cex = cex
10389 
 
10390 
  def read(self, iprot):
10391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10393 
      return
10394 
    iprot.readStructBegin()
10395 
    while True:
10396 
      (fname, ftype, fid) = iprot.readFieldBegin()
10397 
      if ftype == TType.STOP:
10398 
        break
10399 
      if fid == 0:
10400 
        if ftype == TType.LIST:
10401 
          self.success = []
8590 kshitij.so 10402 
          (_etype112, _size109) = iprot.readListBegin()
10403 
          for _i113 in xrange(_size109):
10404 
            _elem114 = iprot.readI64();
10405 
            self.success.append(_elem114)
5944 mandeep.dh 10406 
          iprot.readListEnd()
10407 
        else:
10408 
          iprot.skip(ftype)
10409 
      elif fid == 1:
10410 
        if ftype == TType.STRUCT:
10411 
          self.cex = CatalogServiceException()
10412 
          self.cex.read(iprot)
10413 
        else:
10414 
          iprot.skip(ftype)
10415 
      else:
10416 
        iprot.skip(ftype)
10417 
      iprot.readFieldEnd()
10418 
    iprot.readStructEnd()
10419 
 
10420 
  def write(self, oprot):
10421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10423 
      return
10424 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
10425 
    if self.success is not None:
10426 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10427 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10428 
      for iter115 in self.success:
10429 
        oprot.writeI64(iter115)
5944 mandeep.dh 10430 
      oprot.writeListEnd()
10431 
      oprot.writeFieldEnd()
10432 
    if self.cex is not None:
10433 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10434 
      self.cex.write(oprot)
10435 
      oprot.writeFieldEnd()
10436 
    oprot.writeFieldStop()
10437 
    oprot.writeStructEnd()
10438 
 
10439 
  def validate(self):
10440 
    return
10441 
 
10442 
 
10443 
  def __repr__(self):
10444 
    L = ['%s=%r' % (key, value)
10445 
      for key, value in self.__dict__.iteritems()]
10446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10447 
 
10448 
  def __eq__(self, other):
10449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10450 
 
10451 
  def __ne__(self, other):
10452 
    return not (self == other)
10453 
 
10454 
class getBestDealsCount_args:
10455 
 
10456 
  thrift_spec = (
10457 
  )
10458 
 
10459 
  def read(self, iprot):
10460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10462 
      return
10463 
    iprot.readStructBegin()
10464 
    while True:
10465 
      (fname, ftype, fid) = iprot.readFieldBegin()
10466 
      if ftype == TType.STOP:
10467 
        break
10468 
      else:
10469 
        iprot.skip(ftype)
10470 
      iprot.readFieldEnd()
10471 
    iprot.readStructEnd()
10472 
 
10473 
  def write(self, oprot):
10474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10476 
      return
10477 
    oprot.writeStructBegin('getBestDealsCount_args')
10478 
    oprot.writeFieldStop()
10479 
    oprot.writeStructEnd()
10480 
 
10481 
  def validate(self):
10482 
    return
10483 
 
10484 
 
10485 
  def __repr__(self):
10486 
    L = ['%s=%r' % (key, value)
10487 
      for key, value in self.__dict__.iteritems()]
10488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10489 
 
10490 
  def __eq__(self, other):
10491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10492 
 
10493 
  def __ne__(self, other):
10494 
    return not (self == other)
10495 
 
10496 
class getBestDealsCount_result:
10497 
  """
10498 
  Attributes:
10499 
   - success
10500 
   - cex
10501 
  """
10502 
 
10503 
  thrift_spec = (
10504 
    (0, TType.I64, 'success', None, None, ), # 0
10505 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10506 
  )
10507 
 
10508 
  def __init__(self, success=None, cex=None,):
10509 
    self.success = success
10510 
    self.cex = cex
10511 
 
10512 
  def read(self, iprot):
10513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10515 
      return
10516 
    iprot.readStructBegin()
10517 
    while True:
10518 
      (fname, ftype, fid) = iprot.readFieldBegin()
10519 
      if ftype == TType.STOP:
10520 
        break
10521 
      if fid == 0:
10522 
        if ftype == TType.I64:
10523 
          self.success = iprot.readI64();
10524 
        else:
10525 
          iprot.skip(ftype)
10526 
      elif fid == 1:
10527 
        if ftype == TType.STRUCT:
10528 
          self.cex = CatalogServiceException()
10529 
          self.cex.read(iprot)
10530 
        else:
10531 
          iprot.skip(ftype)
10532 
      else:
10533 
        iprot.skip(ftype)
10534 
      iprot.readFieldEnd()
10535 
    iprot.readStructEnd()
10536 
 
10537 
  def write(self, oprot):
10538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10540 
      return
10541 
    oprot.writeStructBegin('getBestDealsCount_result')
10542 
    if self.success is not None:
10543 
      oprot.writeFieldBegin('success', TType.I64, 0)
10544 
      oprot.writeI64(self.success)
10545 
      oprot.writeFieldEnd()
10546 
    if self.cex is not None:
10547 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10548 
      self.cex.write(oprot)
10549 
      oprot.writeFieldEnd()
10550 
    oprot.writeFieldStop()
10551 
    oprot.writeStructEnd()
10552 
 
10553 
  def validate(self):
10554 
    return
10555 
 
10556 
 
10557 
  def __repr__(self):
10558 
    L = ['%s=%r' % (key, value)
10559 
      for key, value in self.__dict__.iteritems()]
10560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10561 
 
10562 
  def __eq__(self, other):
10563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10564 
 
10565 
  def __ne__(self, other):
10566 
    return not (self == other)
10567 
 
10568 
class getComingSoon_args:
10569 
 
10570 
  thrift_spec = (
10571 
  )
10572 
 
10573 
  def read(self, iprot):
10574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10576 
      return
10577 
    iprot.readStructBegin()
10578 
    while True:
10579 
      (fname, ftype, fid) = iprot.readFieldBegin()
10580 
      if ftype == TType.STOP:
10581 
        break
10582 
      else:
10583 
        iprot.skip(ftype)
10584 
      iprot.readFieldEnd()
10585 
    iprot.readStructEnd()
10586 
 
10587 
  def write(self, oprot):
10588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10590 
      return
10591 
    oprot.writeStructBegin('getComingSoon_args')
10592 
    oprot.writeFieldStop()
10593 
    oprot.writeStructEnd()
10594 
 
10595 
  def validate(self):
10596 
    return
10597 
 
10598 
 
10599 
  def __repr__(self):
10600 
    L = ['%s=%r' % (key, value)
10601 
      for key, value in self.__dict__.iteritems()]
10602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10603 
 
10604 
  def __eq__(self, other):
10605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10606 
 
10607 
  def __ne__(self, other):
10608 
    return not (self == other)
10609 
 
10610 
class getComingSoon_result:
10611 
  """
10612 
  Attributes:
10613 
   - success
10614 
   - isex
10615 
  """
10616 
 
10617 
  thrift_spec = (
10618 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10619 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10620 
  )
10621 
 
10622 
  def __init__(self, success=None, isex=None,):
10623 
    self.success = success
10624 
    self.isex = isex
10625 
 
10626 
  def read(self, iprot):
10627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10629 
      return
10630 
    iprot.readStructBegin()
10631 
    while True:
10632 
      (fname, ftype, fid) = iprot.readFieldBegin()
10633 
      if ftype == TType.STOP:
10634 
        break
10635 
      if fid == 0:
10636 
        if ftype == TType.LIST:
10637 
          self.success = []
8590 kshitij.so 10638 
          (_etype119, _size116) = iprot.readListBegin()
10639 
          for _i120 in xrange(_size116):
10640 
            _elem121 = Item()
10641 
            _elem121.read(iprot)
10642 
            self.success.append(_elem121)
5944 mandeep.dh 10643 
          iprot.readListEnd()
10644 
        else:
10645 
          iprot.skip(ftype)
10646 
      elif fid == 1:
10647 
        if ftype == TType.STRUCT:
10648 
          self.isex = CatalogServiceException()
10649 
          self.isex.read(iprot)
10650 
        else:
10651 
          iprot.skip(ftype)
10652 
      else:
10653 
        iprot.skip(ftype)
10654 
      iprot.readFieldEnd()
10655 
    iprot.readStructEnd()
10656 
 
10657 
  def write(self, oprot):
10658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10660 
      return
10661 
    oprot.writeStructBegin('getComingSoon_result')
10662 
    if self.success is not None:
10663 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10664 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10665 
      for iter122 in self.success:
10666 
        iter122.write(oprot)
5944 mandeep.dh 10667 
      oprot.writeListEnd()
10668 
      oprot.writeFieldEnd()
10669 
    if self.isex is not None:
10670 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10671 
      self.isex.write(oprot)
10672 
      oprot.writeFieldEnd()
10673 
    oprot.writeFieldStop()
10674 
    oprot.writeStructEnd()
10675 
 
10676 
  def validate(self):
10677 
    return
10678 
 
10679 
 
10680 
  def __repr__(self):
10681 
    L = ['%s=%r' % (key, value)
10682 
      for key, value in self.__dict__.iteritems()]
10683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10684 
 
10685 
  def __eq__(self, other):
10686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10687 
 
10688 
  def __ne__(self, other):
10689 
    return not (self == other)
10690 
 
10691 
class getComingSoonCatalogIds_args:
10692 
  """
10693 
  Attributes:
10694 
   - beginIndex
10695 
   - totalItems
10696 
   - brand
10697 
   - category
10698 
  """
10699 
 
10700 
  thrift_spec = (
10701 
    None, # 0
10702 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10703 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10704 
    (3, TType.STRING, 'brand', None, None, ), # 3
10705 
    (4, TType.I64, 'category', None, None, ), # 4
10706 
  )
10707 
 
10708 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10709 
    self.beginIndex = beginIndex
10710 
    self.totalItems = totalItems
10711 
    self.brand = brand
10712 
    self.category = category
10713 
 
10714 
  def read(self, iprot):
10715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10717 
      return
10718 
    iprot.readStructBegin()
10719 
    while True:
10720 
      (fname, ftype, fid) = iprot.readFieldBegin()
10721 
      if ftype == TType.STOP:
10722 
        break
10723 
      if fid == 1:
10724 
        if ftype == TType.I64:
10725 
          self.beginIndex = iprot.readI64();
10726 
        else:
10727 
          iprot.skip(ftype)
10728 
      elif fid == 2:
10729 
        if ftype == TType.I64:
10730 
          self.totalItems = iprot.readI64();
10731 
        else:
10732 
          iprot.skip(ftype)
10733 
      elif fid == 3:
10734 
        if ftype == TType.STRING:
10735 
          self.brand = iprot.readString();
10736 
        else:
10737 
          iprot.skip(ftype)
10738 
      elif fid == 4:
10739 
        if ftype == TType.I64:
10740 
          self.category = iprot.readI64();
10741 
        else:
10742 
          iprot.skip(ftype)
10743 
      else:
10744 
        iprot.skip(ftype)
10745 
      iprot.readFieldEnd()
10746 
    iprot.readStructEnd()
10747 
 
10748 
  def write(self, oprot):
10749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10751 
      return
10752 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
10753 
    if self.beginIndex is not None:
10754 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10755 
      oprot.writeI64(self.beginIndex)
10756 
      oprot.writeFieldEnd()
10757 
    if self.totalItems is not None:
10758 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10759 
      oprot.writeI64(self.totalItems)
10760 
      oprot.writeFieldEnd()
10761 
    if self.brand is not None:
10762 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10763 
      oprot.writeString(self.brand)
10764 
      oprot.writeFieldEnd()
10765 
    if self.category is not None:
10766 
      oprot.writeFieldBegin('category', TType.I64, 4)
10767 
      oprot.writeI64(self.category)
10768 
      oprot.writeFieldEnd()
10769 
    oprot.writeFieldStop()
10770 
    oprot.writeStructEnd()
10771 
 
10772 
  def validate(self):
10773 
    return
10774 
 
10775 
 
10776 
  def __repr__(self):
10777 
    L = ['%s=%r' % (key, value)
10778 
      for key, value in self.__dict__.iteritems()]
10779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10780 
 
10781 
  def __eq__(self, other):
10782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10783 
 
10784 
  def __ne__(self, other):
10785 
    return not (self == other)
10786 
 
10787 
class getComingSoonCatalogIds_result:
10788 
  """
10789 
  Attributes:
10790 
   - success
10791 
   - cex
10792 
  """
10793 
 
10794 
  thrift_spec = (
10795 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10796 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10797 
  )
10798 
 
10799 
  def __init__(self, success=None, cex=None,):
10800 
    self.success = success
10801 
    self.cex = cex
10802 
 
10803 
  def read(self, iprot):
10804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10806 
      return
10807 
    iprot.readStructBegin()
10808 
    while True:
10809 
      (fname, ftype, fid) = iprot.readFieldBegin()
10810 
      if ftype == TType.STOP:
10811 
        break
10812 
      if fid == 0:
10813 
        if ftype == TType.LIST:
10814 
          self.success = []
8590 kshitij.so 10815 
          (_etype126, _size123) = iprot.readListBegin()
10816 
          for _i127 in xrange(_size123):
10817 
            _elem128 = iprot.readI64();
10818 
            self.success.append(_elem128)
5944 mandeep.dh 10819 
          iprot.readListEnd()
10820 
        else:
10821 
          iprot.skip(ftype)
10822 
      elif fid == 1:
10823 
        if ftype == TType.STRUCT:
10824 
          self.cex = CatalogServiceException()
10825 
          self.cex.read(iprot)
10826 
        else:
10827 
          iprot.skip(ftype)
10828 
      else:
10829 
        iprot.skip(ftype)
10830 
      iprot.readFieldEnd()
10831 
    iprot.readStructEnd()
10832 
 
10833 
  def write(self, oprot):
10834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10836 
      return
10837 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
10838 
    if self.success is not None:
10839 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10840 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10841 
      for iter129 in self.success:
10842 
        oprot.writeI64(iter129)
5944 mandeep.dh 10843 
      oprot.writeListEnd()
10844 
      oprot.writeFieldEnd()
10845 
    if self.cex is not None:
10846 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10847 
      self.cex.write(oprot)
10848 
      oprot.writeFieldEnd()
10849 
    oprot.writeFieldStop()
10850 
    oprot.writeStructEnd()
10851 
 
10852 
  def validate(self):
10853 
    return
10854 
 
10855 
 
10856 
  def __repr__(self):
10857 
    L = ['%s=%r' % (key, value)
10858 
      for key, value in self.__dict__.iteritems()]
10859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10860 
 
10861 
  def __eq__(self, other):
10862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10863 
 
10864 
  def __ne__(self, other):
10865 
    return not (self == other)
10866 
 
10867 
class getComingSoonCount_args:
10868 
 
10869 
  thrift_spec = (
10870 
  )
10871 
 
10872 
  def read(self, iprot):
10873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10875 
      return
10876 
    iprot.readStructBegin()
10877 
    while True:
10878 
      (fname, ftype, fid) = iprot.readFieldBegin()
10879 
      if ftype == TType.STOP:
10880 
        break
10881 
      else:
10882 
        iprot.skip(ftype)
10883 
      iprot.readFieldEnd()
10884 
    iprot.readStructEnd()
10885 
 
10886 
  def write(self, oprot):
10887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10889 
      return
10890 
    oprot.writeStructBegin('getComingSoonCount_args')
10891 
    oprot.writeFieldStop()
10892 
    oprot.writeStructEnd()
10893 
 
10894 
  def validate(self):
10895 
    return
10896 
 
10897 
 
10898 
  def __repr__(self):
10899 
    L = ['%s=%r' % (key, value)
10900 
      for key, value in self.__dict__.iteritems()]
10901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10902 
 
10903 
  def __eq__(self, other):
10904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10905 
 
10906 
  def __ne__(self, other):
10907 
    return not (self == other)
10908 
 
10909 
class getComingSoonCount_result:
10910 
  """
10911 
  Attributes:
10912 
   - success
10913 
   - cex
10914 
  """
10915 
 
10916 
  thrift_spec = (
10917 
    (0, TType.I64, 'success', None, None, ), # 0
10918 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10919 
  )
10920 
 
10921 
  def __init__(self, success=None, cex=None,):
10922 
    self.success = success
10923 
    self.cex = cex
10924 
 
10925 
  def read(self, iprot):
10926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10928 
      return
10929 
    iprot.readStructBegin()
10930 
    while True:
10931 
      (fname, ftype, fid) = iprot.readFieldBegin()
10932 
      if ftype == TType.STOP:
10933 
        break
10934 
      if fid == 0:
10935 
        if ftype == TType.I64:
10936 
          self.success = iprot.readI64();
10937 
        else:
10938 
          iprot.skip(ftype)
10939 
      elif fid == 1:
10940 
        if ftype == TType.STRUCT:
10941 
          self.cex = CatalogServiceException()
10942 
          self.cex.read(iprot)
10943 
        else:
10944 
          iprot.skip(ftype)
10945 
      else:
10946 
        iprot.skip(ftype)
10947 
      iprot.readFieldEnd()
10948 
    iprot.readStructEnd()
10949 
 
10950 
  def write(self, oprot):
10951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10953 
      return
10954 
    oprot.writeStructBegin('getComingSoonCount_result')
10955 
    if self.success is not None:
10956 
      oprot.writeFieldBegin('success', TType.I64, 0)
10957 
      oprot.writeI64(self.success)
10958 
      oprot.writeFieldEnd()
10959 
    if self.cex is not None:
10960 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10961 
      self.cex.write(oprot)
10962 
      oprot.writeFieldEnd()
10963 
    oprot.writeFieldStop()
10964 
    oprot.writeStructEnd()
10965 
 
10966 
  def validate(self):
10967 
    return
10968 
 
10969 
 
10970 
  def __repr__(self):
10971 
    L = ['%s=%r' % (key, value)
10972 
      for key, value in self.__dict__.iteritems()]
10973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10974 
 
10975 
  def __eq__(self, other):
10976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10977 
 
10978 
  def __ne__(self, other):
10979 
    return not (self == other)
10980 
 
10981 
class getLatestArrivals_args:
10982 
 
10983 
  thrift_spec = (
10984 
  )
10985 
 
10986 
  def read(self, iprot):
10987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10989 
      return
10990 
    iprot.readStructBegin()
10991 
    while True:
10992 
      (fname, ftype, fid) = iprot.readFieldBegin()
10993 
      if ftype == TType.STOP:
10994 
        break
10995 
      else:
10996 
        iprot.skip(ftype)
10997 
      iprot.readFieldEnd()
10998 
    iprot.readStructEnd()
10999 
 
11000 
  def write(self, oprot):
11001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11003 
      return
11004 
    oprot.writeStructBegin('getLatestArrivals_args')
11005 
    oprot.writeFieldStop()
11006 
    oprot.writeStructEnd()
11007 
 
11008 
  def validate(self):
11009 
    return
11010 
 
11011 
 
11012 
  def __repr__(self):
11013 
    L = ['%s=%r' % (key, value)
11014 
      for key, value in self.__dict__.iteritems()]
11015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11016 
 
11017 
  def __eq__(self, other):
11018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11019 
 
11020 
  def __ne__(self, other):
11021 
    return not (self == other)
11022 
 
11023 
class getLatestArrivals_result:
11024 
  """
11025 
  Attributes:
11026 
   - success
11027 
   - isex
11028 
  """
11029 
 
11030 
  thrift_spec = (
11031 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11032 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11033 
  )
11034 
 
11035 
  def __init__(self, success=None, isex=None,):
11036 
    self.success = success
11037 
    self.isex = isex
11038 
 
11039 
  def read(self, iprot):
11040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11042 
      return
11043 
    iprot.readStructBegin()
11044 
    while True:
11045 
      (fname, ftype, fid) = iprot.readFieldBegin()
11046 
      if ftype == TType.STOP:
11047 
        break
11048 
      if fid == 0:
11049 
        if ftype == TType.LIST:
11050 
          self.success = []
8590 kshitij.so 11051 
          (_etype133, _size130) = iprot.readListBegin()
11052 
          for _i134 in xrange(_size130):
11053 
            _elem135 = Item()
11054 
            _elem135.read(iprot)
11055 
            self.success.append(_elem135)
5944 mandeep.dh 11056 
          iprot.readListEnd()
11057 
        else:
11058 
          iprot.skip(ftype)
11059 
      elif fid == 1:
11060 
        if ftype == TType.STRUCT:
11061 
          self.isex = CatalogServiceException()
11062 
          self.isex.read(iprot)
11063 
        else:
11064 
          iprot.skip(ftype)
11065 
      else:
11066 
        iprot.skip(ftype)
11067 
      iprot.readFieldEnd()
11068 
    iprot.readStructEnd()
11069 
 
11070 
  def write(self, oprot):
11071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11073 
      return
11074 
    oprot.writeStructBegin('getLatestArrivals_result')
11075 
    if self.success is not None:
11076 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11077 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11078 
      for iter136 in self.success:
11079 
        iter136.write(oprot)
5944 mandeep.dh 11080 
      oprot.writeListEnd()
11081 
      oprot.writeFieldEnd()
11082 
    if self.isex is not None:
11083 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11084 
      self.isex.write(oprot)
11085 
      oprot.writeFieldEnd()
11086 
    oprot.writeFieldStop()
11087 
    oprot.writeStructEnd()
11088 
 
11089 
  def validate(self):
11090 
    return
11091 
 
11092 
 
11093 
  def __repr__(self):
11094 
    L = ['%s=%r' % (key, value)
11095 
      for key, value in self.__dict__.iteritems()]
11096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11097 
 
11098 
  def __eq__(self, other):
11099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11100 
 
11101 
  def __ne__(self, other):
11102 
    return not (self == other)
11103 
 
11104 
class getLatestArrivalsCatalogIds_args:
11105 
  """
11106 
  Attributes:
11107 
   - beginIndex
11108 
   - totalItems
11109 
   - brand
11110 
   - categories
11111 
  """
11112 
 
11113 
  thrift_spec = (
11114 
    None, # 0
11115 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11116 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11117 
    (3, TType.STRING, 'brand', None, None, ), # 3
11118 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
11119 
  )
11120 
 
11121 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
11122 
    self.beginIndex = beginIndex
11123 
    self.totalItems = totalItems
11124 
    self.brand = brand
11125 
    self.categories = categories
11126 
 
11127 
  def read(self, iprot):
11128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11130 
      return
11131 
    iprot.readStructBegin()
11132 
    while True:
11133 
      (fname, ftype, fid) = iprot.readFieldBegin()
11134 
      if ftype == TType.STOP:
11135 
        break
11136 
      if fid == 1:
11137 
        if ftype == TType.I64:
11138 
          self.beginIndex = iprot.readI64();
11139 
        else:
11140 
          iprot.skip(ftype)
11141 
      elif fid == 2:
11142 
        if ftype == TType.I64:
11143 
          self.totalItems = iprot.readI64();
11144 
        else:
11145 
          iprot.skip(ftype)
11146 
      elif fid == 3:
11147 
        if ftype == TType.STRING:
11148 
          self.brand = iprot.readString();
11149 
        else:
11150 
          iprot.skip(ftype)
11151 
      elif fid == 4:
11152 
        if ftype == TType.LIST:
11153 
          self.categories = []
8590 kshitij.so 11154 
          (_etype140, _size137) = iprot.readListBegin()
11155 
          for _i141 in xrange(_size137):
11156 
            _elem142 = iprot.readI64();
11157 
            self.categories.append(_elem142)
5944 mandeep.dh 11158 
          iprot.readListEnd()
11159 
        else:
11160 
          iprot.skip(ftype)
11161 
      else:
11162 
        iprot.skip(ftype)
11163 
      iprot.readFieldEnd()
11164 
    iprot.readStructEnd()
11165 
 
11166 
  def write(self, oprot):
11167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11169 
      return
11170 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
11171 
    if self.beginIndex is not None:
11172 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11173 
      oprot.writeI64(self.beginIndex)
11174 
      oprot.writeFieldEnd()
11175 
    if self.totalItems is not None:
11176 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11177 
      oprot.writeI64(self.totalItems)
11178 
      oprot.writeFieldEnd()
11179 
    if self.brand is not None:
11180 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11181 
      oprot.writeString(self.brand)
11182 
      oprot.writeFieldEnd()
11183 
    if self.categories is not None:
11184 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
11185 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 11186 
      for iter143 in self.categories:
11187 
        oprot.writeI64(iter143)
5944 mandeep.dh 11188 
      oprot.writeListEnd()
11189 
      oprot.writeFieldEnd()
11190 
    oprot.writeFieldStop()
11191 
    oprot.writeStructEnd()
11192 
 
11193 
  def validate(self):
11194 
    return
11195 
 
11196 
 
11197 
  def __repr__(self):
11198 
    L = ['%s=%r' % (key, value)
11199 
      for key, value in self.__dict__.iteritems()]
11200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11201 
 
11202 
  def __eq__(self, other):
11203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11204 
 
11205 
  def __ne__(self, other):
11206 
    return not (self == other)
11207 
 
11208 
class getLatestArrivalsCatalogIds_result:
11209 
  """
11210 
  Attributes:
11211 
   - success
11212 
   - cex
11213 
  """
11214 
 
11215 
  thrift_spec = (
11216 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11217 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11218 
  )
11219 
 
11220 
  def __init__(self, success=None, cex=None,):
11221 
    self.success = success
11222 
    self.cex = cex
11223 
 
11224 
  def read(self, iprot):
11225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11227 
      return
11228 
    iprot.readStructBegin()
11229 
    while True:
11230 
      (fname, ftype, fid) = iprot.readFieldBegin()
11231 
      if ftype == TType.STOP:
11232 
        break
11233 
      if fid == 0:
11234 
        if ftype == TType.LIST:
11235 
          self.success = []
8590 kshitij.so 11236 
          (_etype147, _size144) = iprot.readListBegin()
11237 
          for _i148 in xrange(_size144):
11238 
            _elem149 = iprot.readI64();
11239 
            self.success.append(_elem149)
5944 mandeep.dh 11240 
          iprot.readListEnd()
11241 
        else:
11242 
          iprot.skip(ftype)
11243 
      elif fid == 1:
11244 
        if ftype == TType.STRUCT:
11245 
          self.cex = CatalogServiceException()
11246 
          self.cex.read(iprot)
11247 
        else:
11248 
          iprot.skip(ftype)
11249 
      else:
11250 
        iprot.skip(ftype)
11251 
      iprot.readFieldEnd()
11252 
    iprot.readStructEnd()
11253 
 
11254 
  def write(self, oprot):
11255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11257 
      return
11258 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
11259 
    if self.success is not None:
11260 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11261 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11262 
      for iter150 in self.success:
11263 
        oprot.writeI64(iter150)
5944 mandeep.dh 11264 
      oprot.writeListEnd()
11265 
      oprot.writeFieldEnd()
11266 
    if self.cex is not None:
11267 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11268 
      self.cex.write(oprot)
11269 
      oprot.writeFieldEnd()
11270 
    oprot.writeFieldStop()
11271 
    oprot.writeStructEnd()
11272 
 
11273 
  def validate(self):
11274 
    return
11275 
 
11276 
 
11277 
  def __repr__(self):
11278 
    L = ['%s=%r' % (key, value)
11279 
      for key, value in self.__dict__.iteritems()]
11280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11281 
 
11282 
  def __eq__(self, other):
11283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11284 
 
11285 
  def __ne__(self, other):
11286 
    return not (self == other)
11287 
 
11288 
class getLatestArrivalsCount_args:
11289 
 
11290 
  thrift_spec = (
11291 
  )
11292 
 
11293 
  def read(self, iprot):
11294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11296 
      return
11297 
    iprot.readStructBegin()
11298 
    while True:
11299 
      (fname, ftype, fid) = iprot.readFieldBegin()
11300 
      if ftype == TType.STOP:
11301 
        break
11302 
      else:
11303 
        iprot.skip(ftype)
11304 
      iprot.readFieldEnd()
11305 
    iprot.readStructEnd()
11306 
 
11307 
  def write(self, oprot):
11308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11310 
      return
11311 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
11312 
    oprot.writeFieldStop()
11313 
    oprot.writeStructEnd()
11314 
 
11315 
  def validate(self):
11316 
    return
11317 
 
11318 
 
11319 
  def __repr__(self):
11320 
    L = ['%s=%r' % (key, value)
11321 
      for key, value in self.__dict__.iteritems()]
11322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11323 
 
11324 
  def __eq__(self, other):
11325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11326 
 
11327 
  def __ne__(self, other):
11328 
    return not (self == other)
11329 
 
11330 
class getLatestArrivalsCount_result:
11331 
  """
11332 
  Attributes:
11333 
   - success
11334 
   - cex
11335 
  """
11336 
 
11337 
  thrift_spec = (
11338 
    (0, TType.I64, 'success', None, None, ), # 0
11339 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11340 
  )
11341 
 
11342 
  def __init__(self, success=None, cex=None,):
11343 
    self.success = success
11344 
    self.cex = cex
11345 
 
11346 
  def read(self, iprot):
11347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11349 
      return
11350 
    iprot.readStructBegin()
11351 
    while True:
11352 
      (fname, ftype, fid) = iprot.readFieldBegin()
11353 
      if ftype == TType.STOP:
11354 
        break
11355 
      if fid == 0:
11356 
        if ftype == TType.I64:
11357 
          self.success = iprot.readI64();
11358 
        else:
11359 
          iprot.skip(ftype)
11360 
      elif fid == 1:
11361 
        if ftype == TType.STRUCT:
11362 
          self.cex = CatalogServiceException()
11363 
          self.cex.read(iprot)
11364 
        else:
11365 
          iprot.skip(ftype)
11366 
      else:
11367 
        iprot.skip(ftype)
11368 
      iprot.readFieldEnd()
11369 
    iprot.readStructEnd()
11370 
 
11371 
  def write(self, oprot):
11372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11374 
      return
11375 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
11376 
    if self.success is not None:
11377 
      oprot.writeFieldBegin('success', TType.I64, 0)
11378 
      oprot.writeI64(self.success)
11379 
      oprot.writeFieldEnd()
11380 
    if self.cex is not None:
11381 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11382 
      self.cex.write(oprot)
11383 
      oprot.writeFieldEnd()
11384 
    oprot.writeFieldStop()
11385 
    oprot.writeStructEnd()
11386 
 
11387 
  def validate(self):
11388 
    return
11389 
 
11390 
 
11391 
  def __repr__(self):
11392 
    L = ['%s=%r' % (key, value)
11393 
      for key, value in self.__dict__.iteritems()]
11394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11395 
 
11396 
  def __eq__(self, other):
11397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11398 
 
11399 
  def __ne__(self, other):
11400 
    return not (self == other)
11401 
 
11402 
class generateNewEntityID_args:
11403 
 
11404 
  thrift_spec = (
11405 
  )
11406 
 
11407 
  def read(self, iprot):
11408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11410 
      return
11411 
    iprot.readStructBegin()
11412 
    while True:
11413 
      (fname, ftype, fid) = iprot.readFieldBegin()
11414 
      if ftype == TType.STOP:
11415 
        break
11416 
      else:
11417 
        iprot.skip(ftype)
11418 
      iprot.readFieldEnd()
11419 
    iprot.readStructEnd()
11420 
 
11421 
  def write(self, oprot):
11422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11424 
      return
11425 
    oprot.writeStructBegin('generateNewEntityID_args')
11426 
    oprot.writeFieldStop()
11427 
    oprot.writeStructEnd()
11428 
 
11429 
  def validate(self):
11430 
    return
11431 
 
11432 
 
11433 
  def __repr__(self):
11434 
    L = ['%s=%r' % (key, value)
11435 
      for key, value in self.__dict__.iteritems()]
11436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11437 
 
11438 
  def __eq__(self, other):
11439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11440 
 
11441 
  def __ne__(self, other):
11442 
    return not (self == other)
11443 
 
11444 
class generateNewEntityID_result:
11445 
  """
11446 
  Attributes:
11447 
   - success
11448 
  """
11449 
 
11450 
  thrift_spec = (
11451 
    (0, TType.I64, 'success', None, None, ), # 0
11452 
  )
11453 
 
11454 
  def __init__(self, success=None,):
11455 
    self.success = success
11456 
 
11457 
  def read(self, iprot):
11458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11460 
      return
11461 
    iprot.readStructBegin()
11462 
    while True:
11463 
      (fname, ftype, fid) = iprot.readFieldBegin()
11464 
      if ftype == TType.STOP:
11465 
        break
11466 
      if fid == 0:
11467 
        if ftype == TType.I64:
11468 
          self.success = iprot.readI64();
11469 
        else:
11470 
          iprot.skip(ftype)
11471 
      else:
11472 
        iprot.skip(ftype)
11473 
      iprot.readFieldEnd()
11474 
    iprot.readStructEnd()
11475 
 
11476 
  def write(self, oprot):
11477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11479 
      return
11480 
    oprot.writeStructBegin('generateNewEntityID_result')
11481 
    if self.success is not None:
11482 
      oprot.writeFieldBegin('success', TType.I64, 0)
11483 
      oprot.writeI64(self.success)
11484 
      oprot.writeFieldEnd()
11485 
    oprot.writeFieldStop()
11486 
    oprot.writeStructEnd()
11487 
 
11488 
  def validate(self):
11489 
    return
11490 
 
11491 
 
11492 
  def __repr__(self):
11493 
    L = ['%s=%r' % (key, value)
11494 
      for key, value in self.__dict__.iteritems()]
11495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11496 
 
11497 
  def __eq__(self, other):
11498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11499 
 
11500 
  def __ne__(self, other):
11501 
    return not (self == other)
11502 
 
11503 
class addCategory_args:
11504 
  """
11505 
  Attributes:
11506 
   - category
11507 
  """
11508 
 
11509 
  thrift_spec = (
11510 
    None, # 0
11511 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
11512 
  )
11513 
 
11514 
  def __init__(self, category=None,):
11515 
    self.category = category
11516 
 
11517 
  def read(self, iprot):
11518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11520 
      return
11521 
    iprot.readStructBegin()
11522 
    while True:
11523 
      (fname, ftype, fid) = iprot.readFieldBegin()
11524 
      if ftype == TType.STOP:
11525 
        break
11526 
      if fid == 1:
11527 
        if ftype == TType.STRUCT:
11528 
          self.category = Category()
11529 
          self.category.read(iprot)
11530 
        else:
11531 
          iprot.skip(ftype)
11532 
      else:
11533 
        iprot.skip(ftype)
11534 
      iprot.readFieldEnd()
11535 
    iprot.readStructEnd()
11536 
 
11537 
  def write(self, oprot):
11538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11540 
      return
11541 
    oprot.writeStructBegin('addCategory_args')
11542 
    if self.category is not None:
11543 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
11544 
      self.category.write(oprot)
11545 
      oprot.writeFieldEnd()
11546 
    oprot.writeFieldStop()
11547 
    oprot.writeStructEnd()
11548 
 
11549 
  def validate(self):
11550 
    return
11551 
 
11552 
 
11553 
  def __repr__(self):
11554 
    L = ['%s=%r' % (key, value)
11555 
      for key, value in self.__dict__.iteritems()]
11556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11557 
 
11558 
  def __eq__(self, other):
11559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11560 
 
11561 
  def __ne__(self, other):
11562 
    return not (self == other)
11563 
 
11564 
class addCategory_result:
11565 
  """
11566 
  Attributes:
11567 
   - success
11568 
  """
11569 
 
11570 
  thrift_spec = (
11571 
    (0, TType.BOOL, 'success', None, None, ), # 0
11572 
  )
11573 
 
11574 
  def __init__(self, success=None,):
11575 
    self.success = success
11576 
 
11577 
  def read(self, iprot):
11578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11580 
      return
11581 
    iprot.readStructBegin()
11582 
    while True:
11583 
      (fname, ftype, fid) = iprot.readFieldBegin()
11584 
      if ftype == TType.STOP:
11585 
        break
11586 
      if fid == 0:
11587 
        if ftype == TType.BOOL:
11588 
          self.success = iprot.readBool();
11589 
        else:
11590 
          iprot.skip(ftype)
11591 
      else:
11592 
        iprot.skip(ftype)
11593 
      iprot.readFieldEnd()
11594 
    iprot.readStructEnd()
11595 
 
11596 
  def write(self, oprot):
11597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11599 
      return
11600 
    oprot.writeStructBegin('addCategory_result')
11601 
    if self.success is not None:
11602 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11603 
      oprot.writeBool(self.success)
11604 
      oprot.writeFieldEnd()
11605 
    oprot.writeFieldStop()
11606 
    oprot.writeStructEnd()
11607 
 
11608 
  def validate(self):
11609 
    return
11610 
 
11611 
 
11612 
  def __repr__(self):
11613 
    L = ['%s=%r' % (key, value)
11614 
      for key, value in self.__dict__.iteritems()]
11615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11616 
 
11617 
  def __eq__(self, other):
11618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11619 
 
11620 
  def __ne__(self, other):
11621 
    return not (self == other)
11622 
 
11623 
class getCategory_args:
11624 
  """
11625 
  Attributes:
11626 
   - id
11627 
  """
11628 
 
11629 
  thrift_spec = (
11630 
    None, # 0
11631 
    (1, TType.I64, 'id', None, None, ), # 1
11632 
  )
11633 
 
11634 
  def __init__(self, id=None,):
11635 
    self.id = id
11636 
 
11637 
  def read(self, iprot):
11638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11640 
      return
11641 
    iprot.readStructBegin()
11642 
    while True:
11643 
      (fname, ftype, fid) = iprot.readFieldBegin()
11644 
      if ftype == TType.STOP:
11645 
        break
11646 
      if fid == 1:
11647 
        if ftype == TType.I64:
11648 
          self.id = iprot.readI64();
11649 
        else:
11650 
          iprot.skip(ftype)
11651 
      else:
11652 
        iprot.skip(ftype)
11653 
      iprot.readFieldEnd()
11654 
    iprot.readStructEnd()
11655 
 
11656 
  def write(self, oprot):
11657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11659 
      return
11660 
    oprot.writeStructBegin('getCategory_args')
11661 
    if self.id is not None:
11662 
      oprot.writeFieldBegin('id', TType.I64, 1)
11663 
      oprot.writeI64(self.id)
11664 
      oprot.writeFieldEnd()
11665 
    oprot.writeFieldStop()
11666 
    oprot.writeStructEnd()
11667 
 
11668 
  def validate(self):
11669 
    return
11670 
 
11671 
 
11672 
  def __repr__(self):
11673 
    L = ['%s=%r' % (key, value)
11674 
      for key, value in self.__dict__.iteritems()]
11675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11676 
 
11677 
  def __eq__(self, other):
11678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11679 
 
11680 
  def __ne__(self, other):
11681 
    return not (self == other)
11682 
 
11683 
class getCategory_result:
11684 
  """
11685 
  Attributes:
11686 
   - success
11687 
  """
11688 
 
11689 
  thrift_spec = (
11690 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
11691 
  )
11692 
 
11693 
  def __init__(self, success=None,):
11694 
    self.success = success
11695 
 
11696 
  def read(self, iprot):
11697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11699 
      return
11700 
    iprot.readStructBegin()
11701 
    while True:
11702 
      (fname, ftype, fid) = iprot.readFieldBegin()
11703 
      if ftype == TType.STOP:
11704 
        break
11705 
      if fid == 0:
11706 
        if ftype == TType.STRUCT:
11707 
          self.success = Category()
11708 
          self.success.read(iprot)
11709 
        else:
11710 
          iprot.skip(ftype)
11711 
      else:
11712 
        iprot.skip(ftype)
11713 
      iprot.readFieldEnd()
11714 
    iprot.readStructEnd()
11715 
 
11716 
  def write(self, oprot):
11717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11719 
      return
11720 
    oprot.writeStructBegin('getCategory_result')
11721 
    if self.success is not None:
11722 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11723 
      self.success.write(oprot)
11724 
      oprot.writeFieldEnd()
11725 
    oprot.writeFieldStop()
11726 
    oprot.writeStructEnd()
11727 
 
11728 
  def validate(self):
11729 
    return
11730 
 
11731 
 
11732 
  def __repr__(self):
11733 
    L = ['%s=%r' % (key, value)
11734 
      for key, value in self.__dict__.iteritems()]
11735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11736 
 
11737 
  def __eq__(self, other):
11738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11739 
 
11740 
  def __ne__(self, other):
11741 
    return not (self == other)
11742 
 
11743 
class getAllCategories_args:
11744 
 
11745 
  thrift_spec = (
11746 
  )
11747 
 
11748 
  def read(self, iprot):
11749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11751 
      return
11752 
    iprot.readStructBegin()
11753 
    while True:
11754 
      (fname, ftype, fid) = iprot.readFieldBegin()
11755 
      if ftype == TType.STOP:
11756 
        break
11757 
      else:
11758 
        iprot.skip(ftype)
11759 
      iprot.readFieldEnd()
11760 
    iprot.readStructEnd()
11761 
 
11762 
  def write(self, oprot):
11763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11765 
      return
11766 
    oprot.writeStructBegin('getAllCategories_args')
11767 
    oprot.writeFieldStop()
11768 
    oprot.writeStructEnd()
11769 
 
11770 
  def validate(self):
11771 
    return
11772 
 
11773 
 
11774 
  def __repr__(self):
11775 
    L = ['%s=%r' % (key, value)
11776 
      for key, value in self.__dict__.iteritems()]
11777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11778 
 
11779 
  def __eq__(self, other):
11780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11781 
 
11782 
  def __ne__(self, other):
11783 
    return not (self == other)
11784 
 
11785 
class getAllCategories_result:
11786 
  """
11787 
  Attributes:
11788 
   - success
11789 
  """
11790 
 
11791 
  thrift_spec = (
11792 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
11793 
  )
11794 
 
11795 
  def __init__(self, success=None,):
11796 
    self.success = success
11797 
 
11798 
  def read(self, iprot):
11799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11801 
      return
11802 
    iprot.readStructBegin()
11803 
    while True:
11804 
      (fname, ftype, fid) = iprot.readFieldBegin()
11805 
      if ftype == TType.STOP:
11806 
        break
11807 
      if fid == 0:
11808 
        if ftype == TType.LIST:
11809 
          self.success = []
8590 kshitij.so 11810 
          (_etype154, _size151) = iprot.readListBegin()
11811 
          for _i155 in xrange(_size151):
11812 
            _elem156 = Category()
11813 
            _elem156.read(iprot)
11814 
            self.success.append(_elem156)
5944 mandeep.dh 11815 
          iprot.readListEnd()
11816 
        else:
11817 
          iprot.skip(ftype)
11818 
      else:
11819 
        iprot.skip(ftype)
11820 
      iprot.readFieldEnd()
11821 
    iprot.readStructEnd()
11822 
 
11823 
  def write(self, oprot):
11824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11826 
      return
11827 
    oprot.writeStructBegin('getAllCategories_result')
11828 
    if self.success is not None:
11829 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11830 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11831 
      for iter157 in self.success:
11832 
        iter157.write(oprot)
5944 mandeep.dh 11833 
      oprot.writeListEnd()
11834 
      oprot.writeFieldEnd()
11835 
    oprot.writeFieldStop()
11836 
    oprot.writeStructEnd()
11837 
 
11838 
  def validate(self):
11839 
    return
11840 
 
11841 
 
11842 
  def __repr__(self):
11843 
    L = ['%s=%r' % (key, value)
11844 
      for key, value in self.__dict__.iteritems()]
11845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11846 
 
11847 
  def __eq__(self, other):
11848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11849 
 
11850 
  def __ne__(self, other):
11851 
    return not (self == other)
11852 
 
11853 
class getAllSimilarItems_args:
11854 
  """
11855 
  Attributes:
11856 
   - itemId
11857 
  """
11858 
 
11859 
  thrift_spec = (
11860 
    None, # 0
11861 
    (1, TType.I64, 'itemId', None, None, ), # 1
11862 
  )
11863 
 
11864 
  def __init__(self, itemId=None,):
11865 
    self.itemId = itemId
11866 
 
11867 
  def read(self, iprot):
11868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11870 
      return
11871 
    iprot.readStructBegin()
11872 
    while True:
11873 
      (fname, ftype, fid) = iprot.readFieldBegin()
11874 
      if ftype == TType.STOP:
11875 
        break
11876 
      if fid == 1:
11877 
        if ftype == TType.I64:
11878 
          self.itemId = iprot.readI64();
11879 
        else:
11880 
          iprot.skip(ftype)
11881 
      else:
11882 
        iprot.skip(ftype)
11883 
      iprot.readFieldEnd()
11884 
    iprot.readStructEnd()
11885 
 
11886 
  def write(self, oprot):
11887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11889 
      return
11890 
    oprot.writeStructBegin('getAllSimilarItems_args')
11891 
    if self.itemId is not None:
11892 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11893 
      oprot.writeI64(self.itemId)
11894 
      oprot.writeFieldEnd()
11895 
    oprot.writeFieldStop()
11896 
    oprot.writeStructEnd()
11897 
 
11898 
  def validate(self):
11899 
    return
11900 
 
11901 
 
11902 
  def __repr__(self):
11903 
    L = ['%s=%r' % (key, value)
11904 
      for key, value in self.__dict__.iteritems()]
11905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11906 
 
11907 
  def __eq__(self, other):
11908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11909 
 
11910 
  def __ne__(self, other):
11911 
    return not (self == other)
11912 
 
11913 
class getAllSimilarItems_result:
11914 
  """
11915 
  Attributes:
11916 
   - success
11917 
  """
11918 
 
11919 
  thrift_spec = (
11920 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11921 
  )
11922 
 
11923 
  def __init__(self, success=None,):
11924 
    self.success = success
11925 
 
11926 
  def read(self, iprot):
11927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11929 
      return
11930 
    iprot.readStructBegin()
11931 
    while True:
11932 
      (fname, ftype, fid) = iprot.readFieldBegin()
11933 
      if ftype == TType.STOP:
11934 
        break
11935 
      if fid == 0:
11936 
        if ftype == TType.LIST:
11937 
          self.success = []
8590 kshitij.so 11938 
          (_etype161, _size158) = iprot.readListBegin()
11939 
          for _i162 in xrange(_size158):
11940 
            _elem163 = Item()
11941 
            _elem163.read(iprot)
11942 
            self.success.append(_elem163)
5944 mandeep.dh 11943 
          iprot.readListEnd()
11944 
        else:
11945 
          iprot.skip(ftype)
11946 
      else:
11947 
        iprot.skip(ftype)
11948 
      iprot.readFieldEnd()
11949 
    iprot.readStructEnd()
11950 
 
11951 
  def write(self, oprot):
11952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11954 
      return
11955 
    oprot.writeStructBegin('getAllSimilarItems_result')
11956 
    if self.success is not None:
11957 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11958 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11959 
      for iter164 in self.success:
11960 
        iter164.write(oprot)
5944 mandeep.dh 11961 
      oprot.writeListEnd()
11962 
      oprot.writeFieldEnd()
11963 
    oprot.writeFieldStop()
11964 
    oprot.writeStructEnd()
11965 
 
11966 
  def validate(self):
11967 
    return
11968 
 
11969 
 
11970 
  def __repr__(self):
11971 
    L = ['%s=%r' % (key, value)
11972 
      for key, value in self.__dict__.iteritems()]
11973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11974 
 
11975 
  def __eq__(self, other):
11976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11977 
 
11978 
  def __ne__(self, other):
11979 
    return not (self == other)
11980 
 
11981 
class addSimilarItem_args:
11982 
  """
11983 
  Attributes:
11984 
   - itemId
11985 
   - catalogItemId
11986 
  """
11987 
 
11988 
  thrift_spec = (
11989 
    None, # 0
11990 
    (1, TType.I64, 'itemId', None, None, ), # 1
11991 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11992 
  )
11993 
 
11994 
  def __init__(self, itemId=None, catalogItemId=None,):
11995 
    self.itemId = itemId
11996 
    self.catalogItemId = catalogItemId
11997 
 
11998 
  def read(self, iprot):
11999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12001 
      return
12002 
    iprot.readStructBegin()
12003 
    while True:
12004 
      (fname, ftype, fid) = iprot.readFieldBegin()
12005 
      if ftype == TType.STOP:
12006 
        break
12007 
      if fid == 1:
12008 
        if ftype == TType.I64:
12009 
          self.itemId = iprot.readI64();
12010 
        else:
12011 
          iprot.skip(ftype)
12012 
      elif fid == 2:
12013 
        if ftype == TType.I64:
12014 
          self.catalogItemId = iprot.readI64();
12015 
        else:
12016 
          iprot.skip(ftype)
12017 
      else:
12018 
        iprot.skip(ftype)
12019 
      iprot.readFieldEnd()
12020 
    iprot.readStructEnd()
12021 
 
12022 
  def write(self, oprot):
12023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12025 
      return
12026 
    oprot.writeStructBegin('addSimilarItem_args')
12027 
    if self.itemId is not None:
12028 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12029 
      oprot.writeI64(self.itemId)
12030 
      oprot.writeFieldEnd()
12031 
    if self.catalogItemId is not None:
12032 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
12033 
      oprot.writeI64(self.catalogItemId)
12034 
      oprot.writeFieldEnd()
12035 
    oprot.writeFieldStop()
12036 
    oprot.writeStructEnd()
12037 
 
12038 
  def validate(self):
12039 
    return
12040 
 
12041 
 
12042 
  def __repr__(self):
12043 
    L = ['%s=%r' % (key, value)
12044 
      for key, value in self.__dict__.iteritems()]
12045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12046 
 
12047 
  def __eq__(self, other):
12048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12049 
 
12050 
  def __ne__(self, other):
12051 
    return not (self == other)
12052 
 
12053 
class addSimilarItem_result:
12054 
  """
12055 
  Attributes:
12056 
   - success
12057 
   - cex
12058 
  """
12059 
 
12060 
  thrift_spec = (
12061 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
12062 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12063 
  )
12064 
 
12065 
  def __init__(self, success=None, cex=None,):
12066 
    self.success = success
12067 
    self.cex = cex
12068 
 
12069 
  def read(self, iprot):
12070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12072 
      return
12073 
    iprot.readStructBegin()
12074 
    while True:
12075 
      (fname, ftype, fid) = iprot.readFieldBegin()
12076 
      if ftype == TType.STOP:
12077 
        break
12078 
      if fid == 0:
12079 
        if ftype == TType.STRUCT:
12080 
          self.success = Item()
12081 
          self.success.read(iprot)
12082 
        else:
12083 
          iprot.skip(ftype)
12084 
      elif fid == 1:
12085 
        if ftype == TType.STRUCT:
12086 
          self.cex = CatalogServiceException()
12087 
          self.cex.read(iprot)
12088 
        else:
12089 
          iprot.skip(ftype)
12090 
      else:
12091 
        iprot.skip(ftype)
12092 
      iprot.readFieldEnd()
12093 
    iprot.readStructEnd()
12094 
 
12095 
  def write(self, oprot):
12096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12098 
      return
12099 
    oprot.writeStructBegin('addSimilarItem_result')
12100 
    if self.success is not None:
12101 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12102 
      self.success.write(oprot)
12103 
      oprot.writeFieldEnd()
12104 
    if self.cex is not None:
12105 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12106 
      self.cex.write(oprot)
12107 
      oprot.writeFieldEnd()
12108 
    oprot.writeFieldStop()
12109 
    oprot.writeStructEnd()
12110 
 
12111 
  def validate(self):
12112 
    return
12113 
 
12114 
 
12115 
  def __repr__(self):
12116 
    L = ['%s=%r' % (key, value)
12117 
      for key, value in self.__dict__.iteritems()]
12118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12119 
 
12120 
  def __eq__(self, other):
12121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12122 
 
12123 
  def __ne__(self, other):
12124 
    return not (self == other)
12125 
 
6512 kshitij.so 12126 
class addTag_args:
12127 
  """
12128 
  Attributes:
12129 
   - displayName
12130 
   - itemId
12131 
  """
12132 
 
12133 
  thrift_spec = (
12134 
    None, # 0
12135 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12136 
    (2, TType.I64, 'itemId', None, None, ), # 2
12137 
  )
12138 
 
12139 
  def __init__(self, displayName=None, itemId=None,):
12140 
    self.displayName = displayName
12141 
    self.itemId = itemId
12142 
 
12143 
  def read(self, iprot):
12144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12146 
      return
12147 
    iprot.readStructBegin()
12148 
    while True:
12149 
      (fname, ftype, fid) = iprot.readFieldBegin()
12150 
      if ftype == TType.STOP:
12151 
        break
12152 
      if fid == 1:
12153 
        if ftype == TType.STRING:
12154 
          self.displayName = iprot.readString();
12155 
        else:
12156 
          iprot.skip(ftype)
12157 
      elif fid == 2:
12158 
        if ftype == TType.I64:
12159 
          self.itemId = iprot.readI64();
12160 
        else:
12161 
          iprot.skip(ftype)
12162 
      else:
12163 
        iprot.skip(ftype)
12164 
      iprot.readFieldEnd()
12165 
    iprot.readStructEnd()
12166 
 
12167 
  def write(self, oprot):
12168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12170 
      return
12171 
    oprot.writeStructBegin('addTag_args')
12172 
    if self.displayName is not None:
12173 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12174 
      oprot.writeString(self.displayName)
12175 
      oprot.writeFieldEnd()
12176 
    if self.itemId is not None:
12177 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12178 
      oprot.writeI64(self.itemId)
12179 
      oprot.writeFieldEnd()
12180 
    oprot.writeFieldStop()
12181 
    oprot.writeStructEnd()
12182 
 
12183 
  def validate(self):
12184 
    return
12185 
 
12186 
 
12187 
  def __repr__(self):
12188 
    L = ['%s=%r' % (key, value)
12189 
      for key, value in self.__dict__.iteritems()]
12190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12191 
 
12192 
  def __eq__(self, other):
12193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12194 
 
12195 
  def __ne__(self, other):
12196 
    return not (self == other)
12197 
 
12198 
class addTag_result:
12199 
  """
12200 
  Attributes:
12201 
   - success
12202 
  """
12203 
 
12204 
  thrift_spec = (
12205 
    (0, TType.BOOL, 'success', None, None, ), # 0
12206 
  )
12207 
 
12208 
  def __init__(self, success=None,):
12209 
    self.success = success
12210 
 
12211 
  def read(self, iprot):
12212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12214 
      return
12215 
    iprot.readStructBegin()
12216 
    while True:
12217 
      (fname, ftype, fid) = iprot.readFieldBegin()
12218 
      if ftype == TType.STOP:
12219 
        break
12220 
      if fid == 0:
12221 
        if ftype == TType.BOOL:
12222 
          self.success = iprot.readBool();
12223 
        else:
12224 
          iprot.skip(ftype)
12225 
      else:
12226 
        iprot.skip(ftype)
12227 
      iprot.readFieldEnd()
12228 
    iprot.readStructEnd()
12229 
 
12230 
  def write(self, oprot):
12231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12233 
      return
12234 
    oprot.writeStructBegin('addTag_result')
12235 
    if self.success is not None:
12236 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12237 
      oprot.writeBool(self.success)
12238 
      oprot.writeFieldEnd()
12239 
    oprot.writeFieldStop()
12240 
    oprot.writeStructEnd()
12241 
 
12242 
  def validate(self):
12243 
    return
12244 
 
12245 
 
12246 
  def __repr__(self):
12247 
    L = ['%s=%r' % (key, value)
12248 
      for key, value in self.__dict__.iteritems()]
12249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12250 
 
12251 
  def __eq__(self, other):
12252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12253 
 
12254 
  def __ne__(self, other):
12255 
    return not (self == other)
12256 
 
12257 
class deleteEntityTag_args:
12258 
  """
12259 
  Attributes:
12260 
   - displayName
12261 
   - itemId
12262 
  """
12263 
 
12264 
  thrift_spec = (
12265 
    None, # 0
12266 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12267 
    (2, TType.I64, 'itemId', None, None, ), # 2
12268 
  )
12269 
 
12270 
  def __init__(self, displayName=None, itemId=None,):
12271 
    self.displayName = displayName
12272 
    self.itemId = itemId
12273 
 
12274 
  def read(self, iprot):
12275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12277 
      return
12278 
    iprot.readStructBegin()
12279 
    while True:
12280 
      (fname, ftype, fid) = iprot.readFieldBegin()
12281 
      if ftype == TType.STOP:
12282 
        break
12283 
      if fid == 1:
12284 
        if ftype == TType.STRING:
12285 
          self.displayName = iprot.readString();
12286 
        else:
12287 
          iprot.skip(ftype)
12288 
      elif fid == 2:
12289 
        if ftype == TType.I64:
12290 
          self.itemId = iprot.readI64();
12291 
        else:
12292 
          iprot.skip(ftype)
12293 
      else:
12294 
        iprot.skip(ftype)
12295 
      iprot.readFieldEnd()
12296 
    iprot.readStructEnd()
12297 
 
12298 
  def write(self, oprot):
12299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12301 
      return
12302 
    oprot.writeStructBegin('deleteEntityTag_args')
12303 
    if self.displayName is not None:
12304 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12305 
      oprot.writeString(self.displayName)
12306 
      oprot.writeFieldEnd()
12307 
    if self.itemId is not None:
12308 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12309 
      oprot.writeI64(self.itemId)
12310 
      oprot.writeFieldEnd()
12311 
    oprot.writeFieldStop()
12312 
    oprot.writeStructEnd()
12313 
 
12314 
  def validate(self):
12315 
    return
12316 
 
12317 
 
12318 
  def __repr__(self):
12319 
    L = ['%s=%r' % (key, value)
12320 
      for key, value in self.__dict__.iteritems()]
12321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12322 
 
12323 
  def __eq__(self, other):
12324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12325 
 
12326 
  def __ne__(self, other):
12327 
    return not (self == other)
12328 
 
12329 
class deleteEntityTag_result:
12330 
  """
12331 
  Attributes:
12332 
   - success
12333 
  """
12334 
 
12335 
  thrift_spec = (
12336 
    (0, TType.BOOL, 'success', None, None, ), # 0
12337 
  )
12338 
 
12339 
  def __init__(self, success=None,):
12340 
    self.success = success
12341 
 
12342 
  def read(self, iprot):
12343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12345 
      return
12346 
    iprot.readStructBegin()
12347 
    while True:
12348 
      (fname, ftype, fid) = iprot.readFieldBegin()
12349 
      if ftype == TType.STOP:
12350 
        break
12351 
      if fid == 0:
12352 
        if ftype == TType.BOOL:
12353 
          self.success = iprot.readBool();
12354 
        else:
12355 
          iprot.skip(ftype)
12356 
      else:
12357 
        iprot.skip(ftype)
12358 
      iprot.readFieldEnd()
12359 
    iprot.readStructEnd()
12360 
 
12361 
  def write(self, oprot):
12362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12364 
      return
12365 
    oprot.writeStructBegin('deleteEntityTag_result')
12366 
    if self.success is not None:
12367 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12368 
      oprot.writeBool(self.success)
12369 
      oprot.writeFieldEnd()
12370 
    oprot.writeFieldStop()
12371 
    oprot.writeStructEnd()
12372 
 
12373 
  def validate(self):
12374 
    return
12375 
 
12376 
 
12377 
  def __repr__(self):
12378 
    L = ['%s=%r' % (key, value)
12379 
      for key, value in self.__dict__.iteritems()]
12380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12381 
 
12382 
  def __eq__(self, other):
12383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12384 
 
12385 
  def __ne__(self, other):
12386 
    return not (self == other)
12387 
 
12388 
class deleteTag_args:
12389 
  """
12390 
  Attributes:
12391 
   - displayName
12392 
  """
12393 
 
12394 
  thrift_spec = (
12395 
    None, # 0
12396 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12397 
  )
12398 
 
12399 
  def __init__(self, displayName=None,):
12400 
    self.displayName = displayName
12401 
 
12402 
  def read(self, iprot):
12403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12405 
      return
12406 
    iprot.readStructBegin()
12407 
    while True:
12408 
      (fname, ftype, fid) = iprot.readFieldBegin()
12409 
      if ftype == TType.STOP:
12410 
        break
12411 
      if fid == 1:
12412 
        if ftype == TType.STRING:
12413 
          self.displayName = iprot.readString();
12414 
        else:
12415 
          iprot.skip(ftype)
12416 
      else:
12417 
        iprot.skip(ftype)
12418 
      iprot.readFieldEnd()
12419 
    iprot.readStructEnd()
12420 
 
12421 
  def write(self, oprot):
12422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12424 
      return
12425 
    oprot.writeStructBegin('deleteTag_args')
12426 
    if self.displayName is not None:
12427 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12428 
      oprot.writeString(self.displayName)
12429 
      oprot.writeFieldEnd()
12430 
    oprot.writeFieldStop()
12431 
    oprot.writeStructEnd()
12432 
 
12433 
  def validate(self):
12434 
    return
12435 
 
12436 
 
12437 
  def __repr__(self):
12438 
    L = ['%s=%r' % (key, value)
12439 
      for key, value in self.__dict__.iteritems()]
12440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12441 
 
12442 
  def __eq__(self, other):
12443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12444 
 
12445 
  def __ne__(self, other):
12446 
    return not (self == other)
12447 
 
12448 
class deleteTag_result:
12449 
  """
12450 
  Attributes:
12451 
   - success
12452 
  """
12453 
 
12454 
  thrift_spec = (
12455 
    (0, TType.BOOL, 'success', None, None, ), # 0
12456 
  )
12457 
 
12458 
  def __init__(self, success=None,):
12459 
    self.success = success
12460 
 
12461 
  def read(self, iprot):
12462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12464 
      return
12465 
    iprot.readStructBegin()
12466 
    while True:
12467 
      (fname, ftype, fid) = iprot.readFieldBegin()
12468 
      if ftype == TType.STOP:
12469 
        break
12470 
      if fid == 0:
12471 
        if ftype == TType.BOOL:
12472 
          self.success = iprot.readBool();
12473 
        else:
12474 
          iprot.skip(ftype)
12475 
      else:
12476 
        iprot.skip(ftype)
12477 
      iprot.readFieldEnd()
12478 
    iprot.readStructEnd()
12479 
 
12480 
  def write(self, oprot):
12481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12483 
      return
12484 
    oprot.writeStructBegin('deleteTag_result')
12485 
    if self.success is not None:
12486 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12487 
      oprot.writeBool(self.success)
12488 
      oprot.writeFieldEnd()
12489 
    oprot.writeFieldStop()
12490 
    oprot.writeStructEnd()
12491 
 
12492 
  def validate(self):
12493 
    return
12494 
 
12495 
 
12496 
  def __repr__(self):
12497 
    L = ['%s=%r' % (key, value)
12498 
      for key, value in self.__dict__.iteritems()]
12499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12500 
 
12501 
  def __eq__(self, other):
12502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12503 
 
12504 
  def __ne__(self, other):
12505 
    return not (self == other)
12506 
 
12507 
class getAllTags_args:
12508 
 
12509 
  thrift_spec = (
12510 
  )
12511 
 
12512 
  def read(self, iprot):
12513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12515 
      return
12516 
    iprot.readStructBegin()
12517 
    while True:
12518 
      (fname, ftype, fid) = iprot.readFieldBegin()
12519 
      if ftype == TType.STOP:
12520 
        break
12521 
      else:
12522 
        iprot.skip(ftype)
12523 
      iprot.readFieldEnd()
12524 
    iprot.readStructEnd()
12525 
 
12526 
  def write(self, oprot):
12527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12529 
      return
12530 
    oprot.writeStructBegin('getAllTags_args')
12531 
    oprot.writeFieldStop()
12532 
    oprot.writeStructEnd()
12533 
 
12534 
  def validate(self):
12535 
    return
12536 
 
12537 
 
12538 
  def __repr__(self):
12539 
    L = ['%s=%r' % (key, value)
12540 
      for key, value in self.__dict__.iteritems()]
12541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12542 
 
12543 
  def __eq__(self, other):
12544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12545 
 
12546 
  def __ne__(self, other):
12547 
    return not (self == other)
12548 
 
12549 
class getAllTags_result:
12550 
  """
12551 
  Attributes:
12552 
   - success
12553 
  """
12554 
 
12555 
  thrift_spec = (
12556 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12557 
  )
12558 
 
12559 
  def __init__(self, success=None,):
12560 
    self.success = success
12561 
 
12562 
  def read(self, iprot):
12563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12565 
      return
12566 
    iprot.readStructBegin()
12567 
    while True:
12568 
      (fname, ftype, fid) = iprot.readFieldBegin()
12569 
      if ftype == TType.STOP:
12570 
        break
12571 
      if fid == 0:
12572 
        if ftype == TType.LIST:
12573 
          self.success = []
8590 kshitij.so 12574 
          (_etype168, _size165) = iprot.readListBegin()
12575 
          for _i169 in xrange(_size165):
12576 
            _elem170 = iprot.readString();
12577 
            self.success.append(_elem170)
6512 kshitij.so 12578 
          iprot.readListEnd()
12579 
        else:
12580 
          iprot.skip(ftype)
12581 
      else:
12582 
        iprot.skip(ftype)
12583 
      iprot.readFieldEnd()
12584 
    iprot.readStructEnd()
12585 
 
12586 
  def write(self, oprot):
12587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12589 
      return
12590 
    oprot.writeStructBegin('getAllTags_result')
12591 
    if self.success is not None:
12592 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12593 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 12594 
      for iter171 in self.success:
12595 
        oprot.writeString(iter171)
6512 kshitij.so 12596 
      oprot.writeListEnd()
12597 
      oprot.writeFieldEnd()
12598 
    oprot.writeFieldStop()
12599 
    oprot.writeStructEnd()
12600 
 
12601 
  def validate(self):
12602 
    return
12603 
 
12604 
 
12605 
  def __repr__(self):
12606 
    L = ['%s=%r' % (key, value)
12607 
      for key, value in self.__dict__.iteritems()]
12608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12609 
 
12610 
  def __eq__(self, other):
12611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12612 
 
12613 
  def __ne__(self, other):
12614 
    return not (self == other)
12615 
 
12616 
class getAllEntitiesByTagName_args:
12617 
  """
12618 
  Attributes:
12619 
   - displayName
12620 
  """
12621 
 
12622 
  thrift_spec = (
12623 
    None, # 0
12624 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12625 
  )
12626 
 
12627 
  def __init__(self, displayName=None,):
12628 
    self.displayName = displayName
12629 
 
12630 
  def read(self, iprot):
12631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12633 
      return
12634 
    iprot.readStructBegin()
12635 
    while True:
12636 
      (fname, ftype, fid) = iprot.readFieldBegin()
12637 
      if ftype == TType.STOP:
12638 
        break
12639 
      if fid == 1:
12640 
        if ftype == TType.STRING:
12641 
          self.displayName = iprot.readString();
12642 
        else:
12643 
          iprot.skip(ftype)
12644 
      else:
12645 
        iprot.skip(ftype)
12646 
      iprot.readFieldEnd()
12647 
    iprot.readStructEnd()
12648 
 
12649 
  def write(self, oprot):
12650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12652 
      return
12653 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
12654 
    if self.displayName is not None:
12655 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12656 
      oprot.writeString(self.displayName)
12657 
      oprot.writeFieldEnd()
12658 
    oprot.writeFieldStop()
12659 
    oprot.writeStructEnd()
12660 
 
12661 
  def validate(self):
12662 
    return
12663 
 
12664 
 
12665 
  def __repr__(self):
12666 
    L = ['%s=%r' % (key, value)
12667 
      for key, value in self.__dict__.iteritems()]
12668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12669 
 
12670 
  def __eq__(self, other):
12671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12672 
 
12673 
  def __ne__(self, other):
12674 
    return not (self == other)
12675 
 
12676 
class getAllEntitiesByTagName_result:
12677 
  """
12678 
  Attributes:
12679 
   - success
12680 
  """
12681 
 
12682 
  thrift_spec = (
12683 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12684 
  )
12685 
 
12686 
  def __init__(self, success=None,):
12687 
    self.success = success
12688 
 
12689 
  def read(self, iprot):
12690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12692 
      return
12693 
    iprot.readStructBegin()
12694 
    while True:
12695 
      (fname, ftype, fid) = iprot.readFieldBegin()
12696 
      if ftype == TType.STOP:
12697 
        break
12698 
      if fid == 0:
12699 
        if ftype == TType.LIST:
12700 
          self.success = []
8590 kshitij.so 12701 
          (_etype175, _size172) = iprot.readListBegin()
12702 
          for _i176 in xrange(_size172):
12703 
            _elem177 = iprot.readI64();
12704 
            self.success.append(_elem177)
6512 kshitij.so 12705 
          iprot.readListEnd()
12706 
        else:
12707 
          iprot.skip(ftype)
12708 
      else:
12709 
        iprot.skip(ftype)
12710 
      iprot.readFieldEnd()
12711 
    iprot.readStructEnd()
12712 
 
12713 
  def write(self, oprot):
12714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12716 
      return
12717 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
12718 
    if self.success is not None:
12719 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12720 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12721 
      for iter178 in self.success:
12722 
        oprot.writeI64(iter178)
6512 kshitij.so 12723 
      oprot.writeListEnd()
12724 
      oprot.writeFieldEnd()
12725 
    oprot.writeFieldStop()
12726 
    oprot.writeStructEnd()
12727 
 
12728 
  def validate(self):
12729 
    return
12730 
 
12731 
 
12732 
  def __repr__(self):
12733 
    L = ['%s=%r' % (key, value)
12734 
      for key, value in self.__dict__.iteritems()]
12735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12736 
 
12737 
  def __eq__(self, other):
12738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12739 
 
12740 
  def __ne__(self, other):
12741 
    return not (self == other)
12742 
 
6845 amit.gupta 12743 
class getAllEntityTags_args:
12744 
 
12745 
  thrift_spec = (
12746 
  )
12747 
 
12748 
  def read(self, iprot):
12749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12751 
      return
12752 
    iprot.readStructBegin()
12753 
    while True:
12754 
      (fname, ftype, fid) = iprot.readFieldBegin()
12755 
      if ftype == TType.STOP:
12756 
        break
12757 
      else:
12758 
        iprot.skip(ftype)
12759 
      iprot.readFieldEnd()
12760 
    iprot.readStructEnd()
12761 
 
12762 
  def write(self, oprot):
12763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12765 
      return
12766 
    oprot.writeStructBegin('getAllEntityTags_args')
12767 
    oprot.writeFieldStop()
12768 
    oprot.writeStructEnd()
12769 
 
12770 
  def validate(self):
12771 
    return
12772 
 
12773 
 
12774 
  def __repr__(self):
12775 
    L = ['%s=%r' % (key, value)
12776 
      for key, value in self.__dict__.iteritems()]
12777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12778 
 
12779 
  def __eq__(self, other):
12780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12781 
 
12782 
  def __ne__(self, other):
12783 
    return not (self == other)
12784 
 
12785 
class getAllEntityTags_result:
12786 
  """
12787 
  Attributes:
12788 
   - success
12789 
  """
12790 
 
12791 
  thrift_spec = (
12792 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
12793 
  )
12794 
 
12795 
  def __init__(self, success=None,):
12796 
    self.success = success
12797 
 
12798 
  def read(self, iprot):
12799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12801 
      return
12802 
    iprot.readStructBegin()
12803 
    while True:
12804 
      (fname, ftype, fid) = iprot.readFieldBegin()
12805 
      if ftype == TType.STOP:
12806 
        break
12807 
      if fid == 0:
12808 
        if ftype == TType.MAP:
12809 
          self.success = {}
8590 kshitij.so 12810 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
12811 
          for _i183 in xrange(_size179):
12812 
            _key184 = iprot.readI64();
12813 
            _val185 = []
12814 
            (_etype189, _size186) = iprot.readListBegin()
12815 
            for _i190 in xrange(_size186):
12816 
              _elem191 = iprot.readString();
12817 
              _val185.append(_elem191)
6845 amit.gupta 12818 
            iprot.readListEnd()
8590 kshitij.so 12819 
            self.success[_key184] = _val185
6845 amit.gupta 12820 
          iprot.readMapEnd()
12821 
        else:
12822 
          iprot.skip(ftype)
12823 
      else:
12824 
        iprot.skip(ftype)
12825 
      iprot.readFieldEnd()
12826 
    iprot.readStructEnd()
12827 
 
12828 
  def write(self, oprot):
12829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12831 
      return
12832 
    oprot.writeStructBegin('getAllEntityTags_result')
12833 
    if self.success is not None:
12834 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12835 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 12836 
      for kiter192,viter193 in self.success.items():
12837 
        oprot.writeI64(kiter192)
12838 
        oprot.writeListBegin(TType.STRING, len(viter193))
12839 
        for iter194 in viter193:
12840 
          oprot.writeString(iter194)
6845 amit.gupta 12841 
        oprot.writeListEnd()
12842 
      oprot.writeMapEnd()
12843 
      oprot.writeFieldEnd()
12844 
    oprot.writeFieldStop()
12845 
    oprot.writeStructEnd()
12846 
 
12847 
  def validate(self):
12848 
    return
12849 
 
12850 
 
12851 
  def __repr__(self):
12852 
    L = ['%s=%r' % (key, value)
12853 
      for key, value in self.__dict__.iteritems()]
12854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12855 
 
12856 
  def __eq__(self, other):
12857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12858 
 
12859 
  def __ne__(self, other):
12860 
    return not (self == other)
12861 
 
6850 kshitij.so 12862 
class addBanner_args:
12863 
  """
12864 
  Attributes:
8590 kshitij.so 12865 
   - bannerCongregate
6850 kshitij.so 12866 
  """
12867 
 
12868 
  thrift_spec = (
12869 
    None, # 0
8590 kshitij.so 12870 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 12871 
  )
12872 
 
8590 kshitij.so 12873 
  def __init__(self, bannerCongregate=None,):
12874 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 12875 
 
12876 
  def read(self, iprot):
12877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12879 
      return
12880 
    iprot.readStructBegin()
12881 
    while True:
12882 
      (fname, ftype, fid) = iprot.readFieldBegin()
12883 
      if ftype == TType.STOP:
12884 
        break
12885 
      if fid == 1:
8579 kshitij.so 12886 
        if ftype == TType.STRUCT:
8590 kshitij.so 12887 
          self.bannerCongregate = BannerCongregate()
12888 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 12889 
        else:
12890 
          iprot.skip(ftype)
8579 kshitij.so 12891 
      else:
12892 
        iprot.skip(ftype)
12893 
      iprot.readFieldEnd()
12894 
    iprot.readStructEnd()
12895 
 
12896 
  def write(self, oprot):
12897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12899 
      return
12900 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 12901 
    if self.bannerCongregate is not None:
12902 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
12903 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 12904 
      oprot.writeFieldEnd()
12905 
    oprot.writeFieldStop()
12906 
    oprot.writeStructEnd()
12907 
 
12908 
  def validate(self):
12909 
    return
12910 
 
12911 
 
12912 
  def __repr__(self):
12913 
    L = ['%s=%r' % (key, value)
12914 
      for key, value in self.__dict__.iteritems()]
12915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12916 
 
12917 
  def __eq__(self, other):
12918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12919 
 
12920 
  def __ne__(self, other):
12921 
    return not (self == other)
12922 
 
12923 
class addBanner_result:
12924 
 
12925 
  thrift_spec = (
12926 
  )
12927 
 
12928 
  def read(self, iprot):
12929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12931 
      return
12932 
    iprot.readStructBegin()
12933 
    while True:
12934 
      (fname, ftype, fid) = iprot.readFieldBegin()
12935 
      if ftype == TType.STOP:
12936 
        break
12937 
      else:
12938 
        iprot.skip(ftype)
12939 
      iprot.readFieldEnd()
12940 
    iprot.readStructEnd()
12941 
 
12942 
  def write(self, oprot):
12943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12945 
      return
12946 
    oprot.writeStructBegin('addBanner_result')
12947 
    oprot.writeFieldStop()
12948 
    oprot.writeStructEnd()
12949 
 
12950 
  def validate(self):
12951 
    return
12952 
 
12953 
 
12954 
  def __repr__(self):
12955 
    L = ['%s=%r' % (key, value)
12956 
      for key, value in self.__dict__.iteritems()]
12957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12958 
 
12959 
  def __eq__(self, other):
12960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12961 
 
12962 
  def __ne__(self, other):
12963 
    return not (self == other)
12964 
 
12965 
class updateBanner_args:
12966 
  """
12967 
  Attributes:
12968 
   - banner
12969 
  """
12970 
 
12971 
  thrift_spec = (
12972 
    None, # 0
12973 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
12974 
  )
12975 
 
12976 
  def __init__(self, banner=None,):
12977 
    self.banner = banner
12978 
 
12979 
  def read(self, iprot):
12980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12982 
      return
12983 
    iprot.readStructBegin()
12984 
    while True:
12985 
      (fname, ftype, fid) = iprot.readFieldBegin()
12986 
      if ftype == TType.STOP:
12987 
        break
12988 
      if fid == 1:
12989 
        if ftype == TType.STRUCT:
12990 
          self.banner = Banner()
12991 
          self.banner.read(iprot)
6850 kshitij.so 12992 
        else:
12993 
          iprot.skip(ftype)
12994 
      else:
12995 
        iprot.skip(ftype)
12996 
      iprot.readFieldEnd()
12997 
    iprot.readStructEnd()
12998 
 
12999 
  def write(self, oprot):
13000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13002 
      return
8579 kshitij.so 13003 
    oprot.writeStructBegin('updateBanner_args')
13004 
    if self.banner is not None:
13005 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
13006 
      self.banner.write(oprot)
6850 kshitij.so 13007 
      oprot.writeFieldEnd()
13008 
    oprot.writeFieldStop()
13009 
    oprot.writeStructEnd()
13010 
 
13011 
  def validate(self):
13012 
    return
13013 
 
13014 
 
13015 
  def __repr__(self):
13016 
    L = ['%s=%r' % (key, value)
13017 
      for key, value in self.__dict__.iteritems()]
13018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13019 
 
13020 
  def __eq__(self, other):
13021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13022 
 
13023 
  def __ne__(self, other):
13024 
    return not (self == other)
13025 
 
8579 kshitij.so 13026 
class updateBanner_result:
6850 kshitij.so 13027 
  """
13028 
  Attributes:
13029 
   - success
13030 
  """
13031 
 
13032 
  thrift_spec = (
13033 
    (0, TType.BOOL, 'success', None, None, ), # 0
13034 
  )
13035 
 
13036 
  def __init__(self, success=None,):
13037 
    self.success = success
13038 
 
13039 
  def read(self, iprot):
13040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13042 
      return
13043 
    iprot.readStructBegin()
13044 
    while True:
13045 
      (fname, ftype, fid) = iprot.readFieldBegin()
13046 
      if ftype == TType.STOP:
13047 
        break
13048 
      if fid == 0:
13049 
        if ftype == TType.BOOL:
13050 
          self.success = iprot.readBool();
13051 
        else:
13052 
          iprot.skip(ftype)
13053 
      else:
13054 
        iprot.skip(ftype)
13055 
      iprot.readFieldEnd()
13056 
    iprot.readStructEnd()
13057 
 
13058 
  def write(self, oprot):
13059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13061 
      return
8579 kshitij.so 13062 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 13063 
    if self.success is not None:
13064 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13065 
      oprot.writeBool(self.success)
13066 
      oprot.writeFieldEnd()
13067 
    oprot.writeFieldStop()
13068 
    oprot.writeStructEnd()
13069 
 
13070 
  def validate(self):
13071 
    return
13072 
 
13073 
 
13074 
  def __repr__(self):
13075 
    L = ['%s=%r' % (key, value)
13076 
      for key, value in self.__dict__.iteritems()]
13077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13078 
 
13079 
  def __eq__(self, other):
13080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13081 
 
13082 
  def __ne__(self, other):
13083 
    return not (self == other)
13084 
 
13085 
class getAllBanners_args:
13086 
 
13087 
  thrift_spec = (
13088 
  )
13089 
 
13090 
  def read(self, iprot):
13091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13093 
      return
13094 
    iprot.readStructBegin()
13095 
    while True:
13096 
      (fname, ftype, fid) = iprot.readFieldBegin()
13097 
      if ftype == TType.STOP:
13098 
        break
13099 
      else:
13100 
        iprot.skip(ftype)
13101 
      iprot.readFieldEnd()
13102 
    iprot.readStructEnd()
13103 
 
13104 
  def write(self, oprot):
13105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13107 
      return
13108 
    oprot.writeStructBegin('getAllBanners_args')
13109 
    oprot.writeFieldStop()
13110 
    oprot.writeStructEnd()
13111 
 
13112 
  def validate(self):
13113 
    return
13114 
 
13115 
 
13116 
  def __repr__(self):
13117 
    L = ['%s=%r' % (key, value)
13118 
      for key, value in self.__dict__.iteritems()]
13119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13120 
 
13121 
  def __eq__(self, other):
13122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13123 
 
13124 
  def __ne__(self, other):
13125 
    return not (self == other)
13126 
 
13127 
class getAllBanners_result:
13128 
  """
13129 
  Attributes:
13130 
   - success
13131 
  """
13132 
 
13133 
  thrift_spec = (
8579 kshitij.so 13134 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 13135 
  )
13136 
 
13137 
  def __init__(self, success=None,):
13138 
    self.success = success
13139 
 
13140 
  def read(self, iprot):
13141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13143 
      return
13144 
    iprot.readStructBegin()
13145 
    while True:
13146 
      (fname, ftype, fid) = iprot.readFieldBegin()
13147 
      if ftype == TType.STOP:
13148 
        break
13149 
      if fid == 0:
13150 
        if ftype == TType.LIST:
13151 
          self.success = []
8590 kshitij.so 13152 
          (_etype198, _size195) = iprot.readListBegin()
13153 
          for _i199 in xrange(_size195):
13154 
            _elem200 = Banner()
13155 
            _elem200.read(iprot)
13156 
            self.success.append(_elem200)
6850 kshitij.so 13157 
          iprot.readListEnd()
13158 
        else:
13159 
          iprot.skip(ftype)
13160 
      else:
13161 
        iprot.skip(ftype)
13162 
      iprot.readFieldEnd()
13163 
    iprot.readStructEnd()
13164 
 
13165 
  def write(self, oprot):
13166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13168 
      return
13169 
    oprot.writeStructBegin('getAllBanners_result')
13170 
    if self.success is not None:
13171 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 13172 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13173 
      for iter201 in self.success:
13174 
        iter201.write(oprot)
6850 kshitij.so 13175 
      oprot.writeListEnd()
13176 
      oprot.writeFieldEnd()
13177 
    oprot.writeFieldStop()
13178 
    oprot.writeStructEnd()
13179 
 
13180 
  def validate(self):
13181 
    return
13182 
 
13183 
 
13184 
  def __repr__(self):
13185 
    L = ['%s=%r' % (key, value)
13186 
      for key, value in self.__dict__.iteritems()]
13187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13188 
 
13189 
  def __eq__(self, other):
13190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13191 
 
13192 
  def __ne__(self, other):
13193 
    return not (self == other)
13194 
 
13195 
class deleteBanner_args:
13196 
  """
13197 
  Attributes:
13198 
   - bannerName
9155 kshitij.so 13199 
   - bannerType
6850 kshitij.so 13200 
  """
13201 
 
13202 
  thrift_spec = (
13203 
    None, # 0
13204 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13205 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13206 
  )
13207 
 
9155 kshitij.so 13208 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13209 
    self.bannerName = bannerName
9155 kshitij.so 13210 
    self.bannerType = bannerType
6850 kshitij.so 13211 
 
13212 
  def read(self, iprot):
13213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13215 
      return
13216 
    iprot.readStructBegin()
13217 
    while True:
13218 
      (fname, ftype, fid) = iprot.readFieldBegin()
13219 
      if ftype == TType.STOP:
13220 
        break
13221 
      if fid == 1:
13222 
        if ftype == TType.STRING:
13223 
          self.bannerName = iprot.readString();
13224 
        else:
13225 
          iprot.skip(ftype)
9155 kshitij.so 13226 
      elif fid == 2:
13227 
        if ftype == TType.I32:
13228 
          self.bannerType = iprot.readI32();
13229 
        else:
13230 
          iprot.skip(ftype)
6850 kshitij.so 13231 
      else:
13232 
        iprot.skip(ftype)
13233 
      iprot.readFieldEnd()
13234 
    iprot.readStructEnd()
13235 
 
13236 
  def write(self, oprot):
13237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13239 
      return
13240 
    oprot.writeStructBegin('deleteBanner_args')
13241 
    if self.bannerName is not None:
13242 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13243 
      oprot.writeString(self.bannerName)
13244 
      oprot.writeFieldEnd()
9155 kshitij.so 13245 
    if self.bannerType is not None:
13246 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13247 
      oprot.writeI32(self.bannerType)
13248 
      oprot.writeFieldEnd()
6850 kshitij.so 13249 
    oprot.writeFieldStop()
13250 
    oprot.writeStructEnd()
13251 
 
13252 
  def validate(self):
13253 
    return
13254 
 
13255 
 
13256 
  def __repr__(self):
13257 
    L = ['%s=%r' % (key, value)
13258 
      for key, value in self.__dict__.iteritems()]
13259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13260 
 
13261 
  def __eq__(self, other):
13262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13263 
 
13264 
  def __ne__(self, other):
13265 
    return not (self == other)
13266 
 
13267 
class deleteBanner_result:
13268 
  """
13269 
  Attributes:
13270 
   - success
13271 
  """
13272 
 
13273 
  thrift_spec = (
13274 
    (0, TType.BOOL, 'success', None, None, ), # 0
13275 
  )
13276 
 
13277 
  def __init__(self, success=None,):
13278 
    self.success = success
13279 
 
13280 
  def read(self, iprot):
13281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13283 
      return
13284 
    iprot.readStructBegin()
13285 
    while True:
13286 
      (fname, ftype, fid) = iprot.readFieldBegin()
13287 
      if ftype == TType.STOP:
13288 
        break
13289 
      if fid == 0:
13290 
        if ftype == TType.BOOL:
13291 
          self.success = iprot.readBool();
13292 
        else:
13293 
          iprot.skip(ftype)
13294 
      else:
13295 
        iprot.skip(ftype)
13296 
      iprot.readFieldEnd()
13297 
    iprot.readStructEnd()
13298 
 
13299 
  def write(self, oprot):
13300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13302 
      return
13303 
    oprot.writeStructBegin('deleteBanner_result')
13304 
    if self.success is not None:
13305 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13306 
      oprot.writeBool(self.success)
13307 
      oprot.writeFieldEnd()
13308 
    oprot.writeFieldStop()
13309 
    oprot.writeStructEnd()
13310 
 
13311 
  def validate(self):
13312 
    return
13313 
 
13314 
 
13315 
  def __repr__(self):
13316 
    L = ['%s=%r' % (key, value)
13317 
      for key, value in self.__dict__.iteritems()]
13318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13319 
 
13320 
  def __eq__(self, other):
13321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13322 
 
13323 
  def __ne__(self, other):
13324 
    return not (self == other)
13325 
 
13326 
class getBannerDetails_args:
13327 
  """
13328 
  Attributes:
13329 
   - bannerName
9155 kshitij.so 13330 
   - bannerType
6850 kshitij.so 13331 
  """
13332 
 
13333 
  thrift_spec = (
13334 
    None, # 0
13335 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13336 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13337 
  )
13338 
 
9155 kshitij.so 13339 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13340 
    self.bannerName = bannerName
9155 kshitij.so 13341 
    self.bannerType = bannerType
6850 kshitij.so 13342 
 
13343 
  def read(self, iprot):
13344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13346 
      return
13347 
    iprot.readStructBegin()
13348 
    while True:
13349 
      (fname, ftype, fid) = iprot.readFieldBegin()
13350 
      if ftype == TType.STOP:
13351 
        break
13352 
      if fid == 1:
13353 
        if ftype == TType.STRING:
13354 
          self.bannerName = iprot.readString();
13355 
        else:
13356 
          iprot.skip(ftype)
9155 kshitij.so 13357 
      elif fid == 2:
13358 
        if ftype == TType.I32:
13359 
          self.bannerType = iprot.readI32();
13360 
        else:
13361 
          iprot.skip(ftype)
6850 kshitij.so 13362 
      else:
13363 
        iprot.skip(ftype)
13364 
      iprot.readFieldEnd()
13365 
    iprot.readStructEnd()
13366 
 
13367 
  def write(self, oprot):
13368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13370 
      return
13371 
    oprot.writeStructBegin('getBannerDetails_args')
13372 
    if self.bannerName is not None:
13373 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13374 
      oprot.writeString(self.bannerName)
13375 
      oprot.writeFieldEnd()
9155 kshitij.so 13376 
    if self.bannerType is not None:
13377 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13378 
      oprot.writeI32(self.bannerType)
13379 
      oprot.writeFieldEnd()
6850 kshitij.so 13380 
    oprot.writeFieldStop()
13381 
    oprot.writeStructEnd()
13382 
 
13383 
  def validate(self):
13384 
    return
13385 
 
13386 
 
13387 
  def __repr__(self):
13388 
    L = ['%s=%r' % (key, value)
13389 
      for key, value in self.__dict__.iteritems()]
13390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13391 
 
13392 
  def __eq__(self, other):
13393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13394 
 
13395 
  def __ne__(self, other):
13396 
    return not (self == other)
13397 
 
13398 
class getBannerDetails_result:
13399 
  """
13400 
  Attributes:
13401 
   - success
13402 
  """
13403 
 
13404 
  thrift_spec = (
13405 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
13406 
  )
13407 
 
13408 
  def __init__(self, success=None,):
13409 
    self.success = success
13410 
 
13411 
  def read(self, iprot):
13412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13414 
      return
13415 
    iprot.readStructBegin()
13416 
    while True:
13417 
      (fname, ftype, fid) = iprot.readFieldBegin()
13418 
      if ftype == TType.STOP:
13419 
        break
13420 
      if fid == 0:
13421 
        if ftype == TType.STRUCT:
13422 
          self.success = Banner()
13423 
          self.success.read(iprot)
13424 
        else:
13425 
          iprot.skip(ftype)
13426 
      else:
13427 
        iprot.skip(ftype)
13428 
      iprot.readFieldEnd()
13429 
    iprot.readStructEnd()
13430 
 
13431 
  def write(self, oprot):
13432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13434 
      return
13435 
    oprot.writeStructBegin('getBannerDetails_result')
13436 
    if self.success is not None:
13437 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13438 
      self.success.write(oprot)
13439 
      oprot.writeFieldEnd()
13440 
    oprot.writeFieldStop()
13441 
    oprot.writeStructEnd()
13442 
 
13443 
  def validate(self):
13444 
    return
13445 
 
13446 
 
13447 
  def __repr__(self):
13448 
    L = ['%s=%r' % (key, value)
13449 
      for key, value in self.__dict__.iteritems()]
13450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13451 
 
13452 
  def __eq__(self, other):
13453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13454 
 
13455 
  def __ne__(self, other):
13456 
    return not (self == other)
13457 
 
13458 
class getActiveBanners_args:
13459 
 
13460 
  thrift_spec = (
13461 
  )
13462 
 
13463 
  def read(self, iprot):
13464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13466 
      return
13467 
    iprot.readStructBegin()
13468 
    while True:
13469 
      (fname, ftype, fid) = iprot.readFieldBegin()
13470 
      if ftype == TType.STOP:
13471 
        break
13472 
      else:
13473 
        iprot.skip(ftype)
13474 
      iprot.readFieldEnd()
13475 
    iprot.readStructEnd()
13476 
 
13477 
  def write(self, oprot):
13478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13480 
      return
13481 
    oprot.writeStructBegin('getActiveBanners_args')
13482 
    oprot.writeFieldStop()
13483 
    oprot.writeStructEnd()
13484 
 
13485 
  def validate(self):
13486 
    return
13487 
 
13488 
 
13489 
  def __repr__(self):
13490 
    L = ['%s=%r' % (key, value)
13491 
      for key, value in self.__dict__.iteritems()]
13492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13493 
 
13494 
  def __eq__(self, other):
13495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13496 
 
13497 
  def __ne__(self, other):
13498 
    return not (self == other)
13499 
 
13500 
class getActiveBanners_result:
13501 
  """
13502 
  Attributes:
13503 
   - success
13504 
  """
13505 
 
13506 
  thrift_spec = (
8579 kshitij.so 13507 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 13508 
  )
13509 
 
13510 
  def __init__(self, success=None,):
13511 
    self.success = success
13512 
 
13513 
  def read(self, iprot):
13514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13516 
      return
13517 
    iprot.readStructBegin()
13518 
    while True:
13519 
      (fname, ftype, fid) = iprot.readFieldBegin()
13520 
      if ftype == TType.STOP:
13521 
        break
13522 
      if fid == 0:
8579 kshitij.so 13523 
        if ftype == TType.MAP:
13524 
          self.success = {}
8590 kshitij.so 13525 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
13526 
          for _i206 in xrange(_size202):
13527 
            _key207 = iprot.readString();
13528 
            _val208 = []
13529 
            (_etype212, _size209) = iprot.readListBegin()
13530 
            for _i213 in xrange(_size209):
13531 
              _elem214 = Banner()
13532 
              _elem214.read(iprot)
13533 
              _val208.append(_elem214)
8579 kshitij.so 13534 
            iprot.readListEnd()
8590 kshitij.so 13535 
            self.success[_key207] = _val208
8579 kshitij.so 13536 
          iprot.readMapEnd()
6850 kshitij.so 13537 
        else:
13538 
          iprot.skip(ftype)
13539 
      else:
13540 
        iprot.skip(ftype)
13541 
      iprot.readFieldEnd()
13542 
    iprot.readStructEnd()
13543 
 
13544 
  def write(self, oprot):
13545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13547 
      return
13548 
    oprot.writeStructBegin('getActiveBanners_result')
13549 
    if self.success is not None:
8579 kshitij.so 13550 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13551 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 13552 
      for kiter215,viter216 in self.success.items():
13553 
        oprot.writeString(kiter215)
13554 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
13555 
        for iter217 in viter216:
13556 
          iter217.write(oprot)
8579 kshitij.so 13557 
        oprot.writeListEnd()
13558 
      oprot.writeMapEnd()
6850 kshitij.so 13559 
      oprot.writeFieldEnd()
13560 
    oprot.writeFieldStop()
13561 
    oprot.writeStructEnd()
13562 
 
13563 
  def validate(self):
13564 
    return
13565 
 
13566 
 
13567 
  def __repr__(self):
13568 
    L = ['%s=%r' % (key, value)
13569 
      for key, value in self.__dict__.iteritems()]
13570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13571 
 
13572 
  def __eq__(self, other):
13573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13574 
 
13575 
  def __ne__(self, other):
13576 
    return not (self == other)
13577 
 
6849 kshitij.so 13578 
class addBannerMap_args:
13579 
  """
13580 
  Attributes:
8579 kshitij.so 13581 
   - bannerMaps
6849 kshitij.so 13582 
  """
13583 
 
13584 
  thrift_spec = (
13585 
    None, # 0
8579 kshitij.so 13586 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 13587 
  )
13588 
 
8579 kshitij.so 13589 
  def __init__(self, bannerMaps=None,):
13590 
    self.bannerMaps = bannerMaps
6849 kshitij.so 13591 
 
13592 
  def read(self, iprot):
13593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13595 
      return
13596 
    iprot.readStructBegin()
13597 
    while True:
13598 
      (fname, ftype, fid) = iprot.readFieldBegin()
13599 
      if ftype == TType.STOP:
13600 
        break
13601 
      if fid == 1:
8579 kshitij.so 13602 
        if ftype == TType.LIST:
13603 
          self.bannerMaps = []
8590 kshitij.so 13604 
          (_etype221, _size218) = iprot.readListBegin()
13605 
          for _i222 in xrange(_size218):
13606 
            _elem223 = BannerMap()
13607 
            _elem223.read(iprot)
13608 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 13609 
          iprot.readListEnd()
6849 kshitij.so 13610 
        else:
13611 
          iprot.skip(ftype)
8579 kshitij.so 13612 
      else:
13613 
        iprot.skip(ftype)
13614 
      iprot.readFieldEnd()
13615 
    iprot.readStructEnd()
13616 
 
13617 
  def write(self, oprot):
13618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13620 
      return
13621 
    oprot.writeStructBegin('addBannerMap_args')
13622 
    if self.bannerMaps is not None:
13623 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
13624 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 13625 
      for iter224 in self.bannerMaps:
13626 
        iter224.write(oprot)
8579 kshitij.so 13627 
      oprot.writeListEnd()
13628 
      oprot.writeFieldEnd()
13629 
    oprot.writeFieldStop()
13630 
    oprot.writeStructEnd()
13631 
 
13632 
  def validate(self):
13633 
    return
13634 
 
13635 
 
13636 
  def __repr__(self):
13637 
    L = ['%s=%r' % (key, value)
13638 
      for key, value in self.__dict__.iteritems()]
13639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13640 
 
13641 
  def __eq__(self, other):
13642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13643 
 
13644 
  def __ne__(self, other):
13645 
    return not (self == other)
13646 
 
13647 
class addBannerMap_result:
13648 
  """
13649 
  Attributes:
13650 
   - success
13651 
  """
13652 
 
13653 
  thrift_spec = (
13654 
    (0, TType.BOOL, 'success', None, None, ), # 0
13655 
  )
13656 
 
13657 
  def __init__(self, success=None,):
13658 
    self.success = success
13659 
 
13660 
  def read(self, iprot):
13661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13663 
      return
13664 
    iprot.readStructBegin()
13665 
    while True:
13666 
      (fname, ftype, fid) = iprot.readFieldBegin()
13667 
      if ftype == TType.STOP:
13668 
        break
13669 
      if fid == 0:
13670 
        if ftype == TType.BOOL:
13671 
          self.success = iprot.readBool();
6849 kshitij.so 13672 
        else:
13673 
          iprot.skip(ftype)
8579 kshitij.so 13674 
      else:
13675 
        iprot.skip(ftype)
13676 
      iprot.readFieldEnd()
13677 
    iprot.readStructEnd()
13678 
 
13679 
  def write(self, oprot):
13680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13682 
      return
13683 
    oprot.writeStructBegin('addBannerMap_result')
13684 
    if self.success is not None:
13685 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13686 
      oprot.writeBool(self.success)
13687 
      oprot.writeFieldEnd()
13688 
    oprot.writeFieldStop()
13689 
    oprot.writeStructEnd()
13690 
 
13691 
  def validate(self):
13692 
    return
13693 
 
13694 
 
13695 
  def __repr__(self):
13696 
    L = ['%s=%r' % (key, value)
13697 
      for key, value in self.__dict__.iteritems()]
13698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13699 
 
13700 
  def __eq__(self, other):
13701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13702 
 
13703 
  def __ne__(self, other):
13704 
    return not (self == other)
13705 
 
13706 
class updateBannerMap_args:
13707 
  """
13708 
  Attributes:
13709 
   - bannerMap
13710 
  """
13711 
 
13712 
  thrift_spec = (
13713 
    None, # 0
13714 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
13715 
  )
13716 
 
13717 
  def __init__(self, bannerMap=None,):
13718 
    self.bannerMap = bannerMap
13719 
 
13720 
  def read(self, iprot):
13721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13723 
      return
13724 
    iprot.readStructBegin()
13725 
    while True:
13726 
      (fname, ftype, fid) = iprot.readFieldBegin()
13727 
      if ftype == TType.STOP:
13728 
        break
13729 
      if fid == 1:
13730 
        if ftype == TType.STRUCT:
13731 
          self.bannerMap = BannerMap()
13732 
          self.bannerMap.read(iprot)
6849 kshitij.so 13733 
        else:
13734 
          iprot.skip(ftype)
13735 
      else:
13736 
        iprot.skip(ftype)
13737 
      iprot.readFieldEnd()
13738 
    iprot.readStructEnd()
13739 
 
13740 
  def write(self, oprot):
13741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13743 
      return
8579 kshitij.so 13744 
    oprot.writeStructBegin('updateBannerMap_args')
13745 
    if self.bannerMap is not None:
13746 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
13747 
      self.bannerMap.write(oprot)
6849 kshitij.so 13748 
      oprot.writeFieldEnd()
13749 
    oprot.writeFieldStop()
13750 
    oprot.writeStructEnd()
13751 
 
13752 
  def validate(self):
13753 
    return
13754 
 
13755 
 
13756 
  def __repr__(self):
13757 
    L = ['%s=%r' % (key, value)
13758 
      for key, value in self.__dict__.iteritems()]
13759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13760 
 
13761 
  def __eq__(self, other):
13762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13763 
 
13764 
  def __ne__(self, other):
13765 
    return not (self == other)
13766 
 
8579 kshitij.so 13767 
class updateBannerMap_result:
6849 kshitij.so 13768 
  """
13769 
  Attributes:
13770 
   - success
13771 
  """
13772 
 
13773 
  thrift_spec = (
13774 
    (0, TType.BOOL, 'success', None, None, ), # 0
13775 
  )
13776 
 
13777 
  def __init__(self, success=None,):
13778 
    self.success = success
13779 
 
13780 
  def read(self, iprot):
13781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13783 
      return
13784 
    iprot.readStructBegin()
13785 
    while True:
13786 
      (fname, ftype, fid) = iprot.readFieldBegin()
13787 
      if ftype == TType.STOP:
13788 
        break
13789 
      if fid == 0:
13790 
        if ftype == TType.BOOL:
13791 
          self.success = iprot.readBool();
13792 
        else:
13793 
          iprot.skip(ftype)
13794 
      else:
13795 
        iprot.skip(ftype)
13796 
      iprot.readFieldEnd()
13797 
    iprot.readStructEnd()
13798 
 
13799 
  def write(self, oprot):
13800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13802 
      return
8579 kshitij.so 13803 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 13804 
    if self.success is not None:
13805 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13806 
      oprot.writeBool(self.success)
13807 
      oprot.writeFieldEnd()
13808 
    oprot.writeFieldStop()
13809 
    oprot.writeStructEnd()
13810 
 
13811 
  def validate(self):
13812 
    return
13813 
 
13814 
 
13815 
  def __repr__(self):
13816 
    L = ['%s=%r' % (key, value)
13817 
      for key, value in self.__dict__.iteritems()]
13818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13819 
 
13820 
  def __eq__(self, other):
13821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13822 
 
13823 
  def __ne__(self, other):
13824 
    return not (self == other)
13825 
 
13826 
class deleteBannerMap_args:
13827 
  """
13828 
  Attributes:
13829 
   - bannerName
13830 
  """
13831 
 
13832 
  thrift_spec = (
13833 
    None, # 0
13834 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
13835 
  )
13836 
 
13837 
  def __init__(self, bannerName=None,):
13838 
    self.bannerName = bannerName
13839 
 
13840 
  def read(self, iprot):
13841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13843 
      return
13844 
    iprot.readStructBegin()
13845 
    while True:
13846 
      (fname, ftype, fid) = iprot.readFieldBegin()
13847 
      if ftype == TType.STOP:
13848 
        break
13849 
      if fid == 1:
13850 
        if ftype == TType.STRING:
13851 
          self.bannerName = iprot.readString();
13852 
        else:
13853 
          iprot.skip(ftype)
13854 
      else:
13855 
        iprot.skip(ftype)
13856 
      iprot.readFieldEnd()
13857 
    iprot.readStructEnd()
13858 
 
13859 
  def write(self, oprot):
13860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13862 
      return
13863 
    oprot.writeStructBegin('deleteBannerMap_args')
13864 
    if self.bannerName is not None:
13865 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13866 
      oprot.writeString(self.bannerName)
13867 
      oprot.writeFieldEnd()
13868 
    oprot.writeFieldStop()
13869 
    oprot.writeStructEnd()
13870 
 
13871 
  def validate(self):
13872 
    return
13873 
 
13874 
 
13875 
  def __repr__(self):
13876 
    L = ['%s=%r' % (key, value)
13877 
      for key, value in self.__dict__.iteritems()]
13878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13879 
 
13880 
  def __eq__(self, other):
13881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13882 
 
13883 
  def __ne__(self, other):
13884 
    return not (self == other)
13885 
 
13886 
class deleteBannerMap_result:
13887 
  """
13888 
  Attributes:
13889 
   - success
13890 
  """
13891 
 
13892 
  thrift_spec = (
13893 
    (0, TType.BOOL, 'success', None, None, ), # 0
13894 
  )
13895 
 
13896 
  def __init__(self, success=None,):
13897 
    self.success = success
13898 
 
13899 
  def read(self, iprot):
13900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13902 
      return
13903 
    iprot.readStructBegin()
13904 
    while True:
13905 
      (fname, ftype, fid) = iprot.readFieldBegin()
13906 
      if ftype == TType.STOP:
13907 
        break
13908 
      if fid == 0:
13909 
        if ftype == TType.BOOL:
13910 
          self.success = iprot.readBool();
13911 
        else:
13912 
          iprot.skip(ftype)
13913 
      else:
13914 
        iprot.skip(ftype)
13915 
      iprot.readFieldEnd()
13916 
    iprot.readStructEnd()
13917 
 
13918 
  def write(self, oprot):
13919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13921 
      return
13922 
    oprot.writeStructBegin('deleteBannerMap_result')
13923 
    if self.success is not None:
13924 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13925 
      oprot.writeBool(self.success)
13926 
      oprot.writeFieldEnd()
13927 
    oprot.writeFieldStop()
13928 
    oprot.writeStructEnd()
13929 
 
13930 
  def validate(self):
13931 
    return
13932 
 
13933 
 
13934 
  def __repr__(self):
13935 
    L = ['%s=%r' % (key, value)
13936 
      for key, value in self.__dict__.iteritems()]
13937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13938 
 
13939 
  def __eq__(self, other):
13940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13941 
 
13942 
  def __ne__(self, other):
13943 
    return not (self == other)
13944 
 
13945 
class getBannerMapDetails_args:
13946 
  """
13947 
  Attributes:
13948 
   - bannerName
9155 kshitij.so 13949 
   - bannerType
6849 kshitij.so 13950 
  """
13951 
 
13952 
  thrift_spec = (
13953 
    None, # 0
13954 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13955 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 13956 
  )
13957 
 
9155 kshitij.so 13958 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 13959 
    self.bannerName = bannerName
9155 kshitij.so 13960 
    self.bannerType = bannerType
6849 kshitij.so 13961 
 
13962 
  def read(self, iprot):
13963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13965 
      return
13966 
    iprot.readStructBegin()
13967 
    while True:
13968 
      (fname, ftype, fid) = iprot.readFieldBegin()
13969 
      if ftype == TType.STOP:
13970 
        break
13971 
      if fid == 1:
13972 
        if ftype == TType.STRING:
13973 
          self.bannerName = iprot.readString();
13974 
        else:
13975 
          iprot.skip(ftype)
9155 kshitij.so 13976 
      elif fid == 2:
13977 
        if ftype == TType.I32:
13978 
          self.bannerType = iprot.readI32();
13979 
        else:
13980 
          iprot.skip(ftype)
6849 kshitij.so 13981 
      else:
13982 
        iprot.skip(ftype)
13983 
      iprot.readFieldEnd()
13984 
    iprot.readStructEnd()
13985 
 
13986 
  def write(self, oprot):
13987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13989 
      return
13990 
    oprot.writeStructBegin('getBannerMapDetails_args')
13991 
    if self.bannerName is not None:
13992 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13993 
      oprot.writeString(self.bannerName)
13994 
      oprot.writeFieldEnd()
9155 kshitij.so 13995 
    if self.bannerType is not None:
13996 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13997 
      oprot.writeI32(self.bannerType)
13998 
      oprot.writeFieldEnd()
6849 kshitij.so 13999 
    oprot.writeFieldStop()
14000 
    oprot.writeStructEnd()
14001 
 
14002 
  def validate(self):
14003 
    return
14004 
 
14005 
 
14006 
  def __repr__(self):
14007 
    L = ['%s=%r' % (key, value)
14008 
      for key, value in self.__dict__.iteritems()]
14009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14010 
 
14011 
  def __eq__(self, other):
14012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14013 
 
14014 
  def __ne__(self, other):
14015 
    return not (self == other)
14016 
 
14017 
class getBannerMapDetails_result:
14018 
  """
14019 
  Attributes:
14020 
   - success
14021 
  """
14022 
 
14023 
  thrift_spec = (
14024 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
14025 
  )
14026 
 
14027 
  def __init__(self, success=None,):
14028 
    self.success = success
14029 
 
14030 
  def read(self, iprot):
14031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14033 
      return
14034 
    iprot.readStructBegin()
14035 
    while True:
14036 
      (fname, ftype, fid) = iprot.readFieldBegin()
14037 
      if ftype == TType.STOP:
14038 
        break
14039 
      if fid == 0:
14040 
        if ftype == TType.LIST:
14041 
          self.success = []
8590 kshitij.so 14042 
          (_etype228, _size225) = iprot.readListBegin()
14043 
          for _i229 in xrange(_size225):
14044 
            _elem230 = BannerMap()
14045 
            _elem230.read(iprot)
14046 
            self.success.append(_elem230)
6849 kshitij.so 14047 
          iprot.readListEnd()
14048 
        else:
14049 
          iprot.skip(ftype)
14050 
      else:
14051 
        iprot.skip(ftype)
14052 
      iprot.readFieldEnd()
14053 
    iprot.readStructEnd()
14054 
 
14055 
  def write(self, oprot):
14056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14058 
      return
14059 
    oprot.writeStructBegin('getBannerMapDetails_result')
14060 
    if self.success is not None:
14061 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14062 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14063 
      for iter231 in self.success:
14064 
        iter231.write(oprot)
6849 kshitij.so 14065 
      oprot.writeListEnd()
14066 
      oprot.writeFieldEnd()
14067 
    oprot.writeFieldStop()
14068 
    oprot.writeStructEnd()
14069 
 
14070 
  def validate(self):
14071 
    return
14072 
 
14073 
 
14074 
  def __repr__(self):
14075 
    L = ['%s=%r' % (key, value)
14076 
      for key, value in self.__dict__.iteritems()]
14077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14078 
 
14079 
  def __eq__(self, other):
14080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14081 
 
14082 
  def __ne__(self, other):
14083 
    return not (self == other)
14084 
 
8579 kshitij.so 14085 
class addBannerUri_args:
14086 
  """
14087 
  Attributes:
14088 
   - bannerUriMappings
14089 
  """
14090 
 
14091 
  thrift_spec = (
14092 
    None, # 0
14093 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
14094 
  )
14095 
 
14096 
  def __init__(self, bannerUriMappings=None,):
14097 
    self.bannerUriMappings = bannerUriMappings
14098 
 
14099 
  def read(self, iprot):
14100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14102 
      return
14103 
    iprot.readStructBegin()
14104 
    while True:
14105 
      (fname, ftype, fid) = iprot.readFieldBegin()
14106 
      if ftype == TType.STOP:
14107 
        break
14108 
      if fid == 1:
14109 
        if ftype == TType.LIST:
14110 
          self.bannerUriMappings = []
8590 kshitij.so 14111 
          (_etype235, _size232) = iprot.readListBegin()
14112 
          for _i236 in xrange(_size232):
14113 
            _elem237 = BannerUriMapping()
14114 
            _elem237.read(iprot)
14115 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 14116 
          iprot.readListEnd()
14117 
        else:
14118 
          iprot.skip(ftype)
14119 
      else:
14120 
        iprot.skip(ftype)
14121 
      iprot.readFieldEnd()
14122 
    iprot.readStructEnd()
14123 
 
14124 
  def write(self, oprot):
14125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14127 
      return
14128 
    oprot.writeStructBegin('addBannerUri_args')
14129 
    if self.bannerUriMappings is not None:
14130 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
14131 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 14132 
      for iter238 in self.bannerUriMappings:
14133 
        iter238.write(oprot)
8579 kshitij.so 14134 
      oprot.writeListEnd()
14135 
      oprot.writeFieldEnd()
14136 
    oprot.writeFieldStop()
14137 
    oprot.writeStructEnd()
14138 
 
14139 
  def validate(self):
14140 
    return
14141 
 
14142 
 
14143 
  def __repr__(self):
14144 
    L = ['%s=%r' % (key, value)
14145 
      for key, value in self.__dict__.iteritems()]
14146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14147 
 
14148 
  def __eq__(self, other):
14149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14150 
 
14151 
  def __ne__(self, other):
14152 
    return not (self == other)
14153 
 
14154 
class addBannerUri_result:
14155 
 
14156 
  thrift_spec = (
14157 
  )
14158 
 
14159 
  def read(self, iprot):
14160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14162 
      return
14163 
    iprot.readStructBegin()
14164 
    while True:
14165 
      (fname, ftype, fid) = iprot.readFieldBegin()
14166 
      if ftype == TType.STOP:
14167 
        break
14168 
      else:
14169 
        iprot.skip(ftype)
14170 
      iprot.readFieldEnd()
14171 
    iprot.readStructEnd()
14172 
 
14173 
  def write(self, oprot):
14174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14176 
      return
14177 
    oprot.writeStructBegin('addBannerUri_result')
14178 
    oprot.writeFieldStop()
14179 
    oprot.writeStructEnd()
14180 
 
14181 
  def validate(self):
14182 
    return
14183 
 
14184 
 
14185 
  def __repr__(self):
14186 
    L = ['%s=%r' % (key, value)
14187 
      for key, value in self.__dict__.iteritems()]
14188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14189 
 
14190 
  def __eq__(self, other):
14191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14192 
 
14193 
  def __ne__(self, other):
14194 
    return not (self == other)
14195 
 
14196 
class getUriMapping_args:
14197 
  """
14198 
  Attributes:
14199 
   - bannerName
9155 kshitij.so 14200 
   - bannerType
8579 kshitij.so 14201 
  """
14202 
 
14203 
  thrift_spec = (
14204 
    None, # 0
14205 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14206 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 14207 
  )
14208 
 
9155 kshitij.so 14209 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 14210 
    self.bannerName = bannerName
9155 kshitij.so 14211 
    self.bannerType = bannerType
8579 kshitij.so 14212 
 
14213 
  def read(self, iprot):
14214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14216 
      return
14217 
    iprot.readStructBegin()
14218 
    while True:
14219 
      (fname, ftype, fid) = iprot.readFieldBegin()
14220 
      if ftype == TType.STOP:
14221 
        break
14222 
      if fid == 1:
14223 
        if ftype == TType.STRING:
14224 
          self.bannerName = iprot.readString();
14225 
        else:
14226 
          iprot.skip(ftype)
9155 kshitij.so 14227 
      elif fid == 2:
14228 
        if ftype == TType.I32:
14229 
          self.bannerType = iprot.readI32();
14230 
        else:
14231 
          iprot.skip(ftype)
8579 kshitij.so 14232 
      else:
14233 
        iprot.skip(ftype)
14234 
      iprot.readFieldEnd()
14235 
    iprot.readStructEnd()
14236 
 
14237 
  def write(self, oprot):
14238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14240 
      return
14241 
    oprot.writeStructBegin('getUriMapping_args')
14242 
    if self.bannerName is not None:
14243 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14244 
      oprot.writeString(self.bannerName)
14245 
      oprot.writeFieldEnd()
9155 kshitij.so 14246 
    if self.bannerType is not None:
14247 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14248 
      oprot.writeI32(self.bannerType)
14249 
      oprot.writeFieldEnd()
8579 kshitij.so 14250 
    oprot.writeFieldStop()
14251 
    oprot.writeStructEnd()
14252 
 
14253 
  def validate(self):
14254 
    return
14255 
 
14256 
 
14257 
  def __repr__(self):
14258 
    L = ['%s=%r' % (key, value)
14259 
      for key, value in self.__dict__.iteritems()]
14260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14261 
 
14262 
  def __eq__(self, other):
14263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14264 
 
14265 
  def __ne__(self, other):
14266 
    return not (self == other)
14267 
 
14268 
class getUriMapping_result:
14269 
  """
14270 
  Attributes:
14271 
   - success
14272 
  """
14273 
 
14274 
  thrift_spec = (
14275 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
14276 
  )
14277 
 
14278 
  def __init__(self, success=None,):
14279 
    self.success = success
14280 
 
14281 
  def read(self, iprot):
14282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14284 
      return
14285 
    iprot.readStructBegin()
14286 
    while True:
14287 
      (fname, ftype, fid) = iprot.readFieldBegin()
14288 
      if ftype == TType.STOP:
14289 
        break
14290 
      if fid == 0:
14291 
        if ftype == TType.LIST:
14292 
          self.success = []
8590 kshitij.so 14293 
          (_etype242, _size239) = iprot.readListBegin()
14294 
          for _i243 in xrange(_size239):
14295 
            _elem244 = BannerUriMapping()
14296 
            _elem244.read(iprot)
14297 
            self.success.append(_elem244)
8579 kshitij.so 14298 
          iprot.readListEnd()
14299 
        else:
14300 
          iprot.skip(ftype)
14301 
      else:
14302 
        iprot.skip(ftype)
14303 
      iprot.readFieldEnd()
14304 
    iprot.readStructEnd()
14305 
 
14306 
  def write(self, oprot):
14307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14309 
      return
14310 
    oprot.writeStructBegin('getUriMapping_result')
14311 
    if self.success is not None:
14312 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14313 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14314 
      for iter245 in self.success:
14315 
        iter245.write(oprot)
8579 kshitij.so 14316 
      oprot.writeListEnd()
14317 
      oprot.writeFieldEnd()
14318 
    oprot.writeFieldStop()
14319 
    oprot.writeStructEnd()
14320 
 
14321 
  def validate(self):
14322 
    return
14323 
 
14324 
 
14325 
  def __repr__(self):
14326 
    L = ['%s=%r' % (key, value)
14327 
      for key, value in self.__dict__.iteritems()]
14328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14329 
 
14330 
  def __eq__(self, other):
14331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14332 
 
14333 
  def __ne__(self, other):
14334 
    return not (self == other)
14335 
 
14336 
class addCampaign_args:
14337 
  """
14338 
  Attributes:
14339 
   - campaign
14340 
  """
14341 
 
14342 
  thrift_spec = (
14343 
    None, # 0
14344 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
14345 
  )
14346 
 
14347 
  def __init__(self, campaign=None,):
14348 
    self.campaign = campaign
14349 
 
14350 
  def read(self, iprot):
14351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14353 
      return
14354 
    iprot.readStructBegin()
14355 
    while True:
14356 
      (fname, ftype, fid) = iprot.readFieldBegin()
14357 
      if ftype == TType.STOP:
14358 
        break
14359 
      if fid == 1:
14360 
        if ftype == TType.STRUCT:
14361 
          self.campaign = Campaign()
14362 
          self.campaign.read(iprot)
14363 
        else:
14364 
          iprot.skip(ftype)
14365 
      else:
14366 
        iprot.skip(ftype)
14367 
      iprot.readFieldEnd()
14368 
    iprot.readStructEnd()
14369 
 
14370 
  def write(self, oprot):
14371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14373 
      return
14374 
    oprot.writeStructBegin('addCampaign_args')
14375 
    if self.campaign is not None:
14376 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
14377 
      self.campaign.write(oprot)
14378 
      oprot.writeFieldEnd()
14379 
    oprot.writeFieldStop()
14380 
    oprot.writeStructEnd()
14381 
 
14382 
  def validate(self):
14383 
    return
14384 
 
14385 
 
14386 
  def __repr__(self):
14387 
    L = ['%s=%r' % (key, value)
14388 
      for key, value in self.__dict__.iteritems()]
14389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14390 
 
14391 
  def __eq__(self, other):
14392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14393 
 
14394 
  def __ne__(self, other):
14395 
    return not (self == other)
14396 
 
14397 
class addCampaign_result:
14398 
 
14399 
  thrift_spec = (
14400 
  )
14401 
 
14402 
  def read(self, iprot):
14403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14405 
      return
14406 
    iprot.readStructBegin()
14407 
    while True:
14408 
      (fname, ftype, fid) = iprot.readFieldBegin()
14409 
      if ftype == TType.STOP:
14410 
        break
14411 
      else:
14412 
        iprot.skip(ftype)
14413 
      iprot.readFieldEnd()
14414 
    iprot.readStructEnd()
14415 
 
14416 
  def write(self, oprot):
14417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14419 
      return
14420 
    oprot.writeStructBegin('addCampaign_result')
14421 
    oprot.writeFieldStop()
14422 
    oprot.writeStructEnd()
14423 
 
14424 
  def validate(self):
14425 
    return
14426 
 
14427 
 
14428 
  def __repr__(self):
14429 
    L = ['%s=%r' % (key, value)
14430 
      for key, value in self.__dict__.iteritems()]
14431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14432 
 
14433 
  def __eq__(self, other):
14434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14435 
 
14436 
  def __ne__(self, other):
14437 
    return not (self == other)
14438 
 
14439 
class getCampaigns_args:
14440 
  """
14441 
  Attributes:
14442 
   - campaignName
14443 
  """
14444 
 
14445 
  thrift_spec = (
14446 
    None, # 0
14447 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
14448 
  )
14449 
 
14450 
  def __init__(self, campaignName=None,):
14451 
    self.campaignName = campaignName
14452 
 
14453 
  def read(self, iprot):
14454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14456 
      return
14457 
    iprot.readStructBegin()
14458 
    while True:
14459 
      (fname, ftype, fid) = iprot.readFieldBegin()
14460 
      if ftype == TType.STOP:
14461 
        break
14462 
      if fid == 1:
14463 
        if ftype == TType.STRING:
14464 
          self.campaignName = iprot.readString();
14465 
        else:
14466 
          iprot.skip(ftype)
14467 
      else:
14468 
        iprot.skip(ftype)
14469 
      iprot.readFieldEnd()
14470 
    iprot.readStructEnd()
14471 
 
14472 
  def write(self, oprot):
14473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14475 
      return
14476 
    oprot.writeStructBegin('getCampaigns_args')
14477 
    if self.campaignName is not None:
14478 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
14479 
      oprot.writeString(self.campaignName)
14480 
      oprot.writeFieldEnd()
14481 
    oprot.writeFieldStop()
14482 
    oprot.writeStructEnd()
14483 
 
14484 
  def validate(self):
14485 
    return
14486 
 
14487 
 
14488 
  def __repr__(self):
14489 
    L = ['%s=%r' % (key, value)
14490 
      for key, value in self.__dict__.iteritems()]
14491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14492 
 
14493 
  def __eq__(self, other):
14494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14495 
 
14496 
  def __ne__(self, other):
14497 
    return not (self == other)
14498 
 
14499 
class getCampaigns_result:
14500 
  """
14501 
  Attributes:
14502 
   - success
14503 
  """
14504 
 
14505 
  thrift_spec = (
14506 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
14507 
  )
14508 
 
14509 
  def __init__(self, success=None,):
14510 
    self.success = success
14511 
 
14512 
  def read(self, iprot):
14513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14515 
      return
14516 
    iprot.readStructBegin()
14517 
    while True:
14518 
      (fname, ftype, fid) = iprot.readFieldBegin()
14519 
      if ftype == TType.STOP:
14520 
        break
14521 
      if fid == 0:
14522 
        if ftype == TType.LIST:
14523 
          self.success = []
8590 kshitij.so 14524 
          (_etype249, _size246) = iprot.readListBegin()
14525 
          for _i250 in xrange(_size246):
14526 
            _elem251 = Campaign()
14527 
            _elem251.read(iprot)
14528 
            self.success.append(_elem251)
8579 kshitij.so 14529 
          iprot.readListEnd()
14530 
        else:
14531 
          iprot.skip(ftype)
14532 
      else:
14533 
        iprot.skip(ftype)
14534 
      iprot.readFieldEnd()
14535 
    iprot.readStructEnd()
14536 
 
14537 
  def write(self, oprot):
14538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14540 
      return
14541 
    oprot.writeStructBegin('getCampaigns_result')
14542 
    if self.success is not None:
14543 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14544 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14545 
      for iter252 in self.success:
14546 
        iter252.write(oprot)
8579 kshitij.so 14547 
      oprot.writeListEnd()
14548 
      oprot.writeFieldEnd()
14549 
    oprot.writeFieldStop()
14550 
    oprot.writeStructEnd()
14551 
 
14552 
  def validate(self):
14553 
    return
14554 
 
14555 
 
14556 
  def __repr__(self):
14557 
    L = ['%s=%r' % (key, value)
14558 
      for key, value in self.__dict__.iteritems()]
14559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14560 
 
14561 
  def __eq__(self, other):
14562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14563 
 
14564 
  def __ne__(self, other):
14565 
    return not (self == other)
14566 
 
14567 
class deleteCampaign_args:
14568 
  """
14569 
  Attributes:
14570 
   - campaignId
14571 
  """
14572 
 
14573 
  thrift_spec = (
14574 
    None, # 0
14575 
    (1, TType.I64, 'campaignId', None, None, ), # 1
14576 
  )
14577 
 
14578 
  def __init__(self, campaignId=None,):
14579 
    self.campaignId = campaignId
14580 
 
14581 
  def read(self, iprot):
14582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14584 
      return
14585 
    iprot.readStructBegin()
14586 
    while True:
14587 
      (fname, ftype, fid) = iprot.readFieldBegin()
14588 
      if ftype == TType.STOP:
14589 
        break
14590 
      if fid == 1:
14591 
        if ftype == TType.I64:
14592 
          self.campaignId = iprot.readI64();
14593 
        else:
14594 
          iprot.skip(ftype)
14595 
      else:
14596 
        iprot.skip(ftype)
14597 
      iprot.readFieldEnd()
14598 
    iprot.readStructEnd()
14599 
 
14600 
  def write(self, oprot):
14601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14603 
      return
14604 
    oprot.writeStructBegin('deleteCampaign_args')
14605 
    if self.campaignId is not None:
14606 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
14607 
      oprot.writeI64(self.campaignId)
14608 
      oprot.writeFieldEnd()
14609 
    oprot.writeFieldStop()
14610 
    oprot.writeStructEnd()
14611 
 
14612 
  def validate(self):
14613 
    return
14614 
 
14615 
 
14616 
  def __repr__(self):
14617 
    L = ['%s=%r' % (key, value)
14618 
      for key, value in self.__dict__.iteritems()]
14619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14620 
 
14621 
  def __eq__(self, other):
14622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14623 
 
14624 
  def __ne__(self, other):
14625 
    return not (self == other)
14626 
 
14627 
class deleteCampaign_result:
14628 
 
14629 
  thrift_spec = (
14630 
  )
14631 
 
14632 
  def read(self, iprot):
14633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14635 
      return
14636 
    iprot.readStructBegin()
14637 
    while True:
14638 
      (fname, ftype, fid) = iprot.readFieldBegin()
14639 
      if ftype == TType.STOP:
14640 
        break
14641 
      else:
14642 
        iprot.skip(ftype)
14643 
      iprot.readFieldEnd()
14644 
    iprot.readStructEnd()
14645 
 
14646 
  def write(self, oprot):
14647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14649 
      return
14650 
    oprot.writeStructBegin('deleteCampaign_result')
14651 
    oprot.writeFieldStop()
14652 
    oprot.writeStructEnd()
14653 
 
14654 
  def validate(self):
14655 
    return
14656 
 
14657 
 
14658 
  def __repr__(self):
14659 
    L = ['%s=%r' % (key, value)
14660 
      for key, value in self.__dict__.iteritems()]
14661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14662 
 
14663 
  def __eq__(self, other):
14664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14665 
 
14666 
  def __ne__(self, other):
14667 
    return not (self == other)
14668 
 
14669 
class getAllCampaigns_args:
14670 
 
14671 
  thrift_spec = (
14672 
  )
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 
      else:
14684 
        iprot.skip(ftype)
14685 
      iprot.readFieldEnd()
14686 
    iprot.readStructEnd()
14687 
 
14688 
  def write(self, oprot):
14689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14691 
      return
14692 
    oprot.writeStructBegin('getAllCampaigns_args')
14693 
    oprot.writeFieldStop()
14694 
    oprot.writeStructEnd()
14695 
 
14696 
  def validate(self):
14697 
    return
14698 
 
14699 
 
14700 
  def __repr__(self):
14701 
    L = ['%s=%r' % (key, value)
14702 
      for key, value in self.__dict__.iteritems()]
14703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14704 
 
14705 
  def __eq__(self, other):
14706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14707 
 
14708 
  def __ne__(self, other):
14709 
    return not (self == other)
14710 
 
14711 
class getAllCampaigns_result:
14712 
  """
14713 
  Attributes:
14714 
   - success
14715 
  """
14716 
 
14717 
  thrift_spec = (
14718 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14719 
  )
14720 
 
14721 
  def __init__(self, success=None,):
14722 
    self.success = success
14723 
 
14724 
  def read(self, iprot):
14725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14727 
      return
14728 
    iprot.readStructBegin()
14729 
    while True:
14730 
      (fname, ftype, fid) = iprot.readFieldBegin()
14731 
      if ftype == TType.STOP:
14732 
        break
14733 
      if fid == 0:
14734 
        if ftype == TType.LIST:
14735 
          self.success = []
8590 kshitij.so 14736 
          (_etype256, _size253) = iprot.readListBegin()
14737 
          for _i257 in xrange(_size253):
14738 
            _elem258 = iprot.readString();
14739 
            self.success.append(_elem258)
8579 kshitij.so 14740 
          iprot.readListEnd()
14741 
        else:
14742 
          iprot.skip(ftype)
14743 
      else:
14744 
        iprot.skip(ftype)
14745 
      iprot.readFieldEnd()
14746 
    iprot.readStructEnd()
14747 
 
14748 
  def write(self, oprot):
14749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14751 
      return
14752 
    oprot.writeStructBegin('getAllCampaigns_result')
14753 
    if self.success is not None:
14754 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14755 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14756 
      for iter259 in self.success:
14757 
        oprot.writeString(iter259)
8579 kshitij.so 14758 
      oprot.writeListEnd()
14759 
      oprot.writeFieldEnd()
14760 
    oprot.writeFieldStop()
14761 
    oprot.writeStructEnd()
14762 
 
14763 
  def validate(self):
14764 
    return
14765 
 
14766 
 
14767 
  def __repr__(self):
14768 
    L = ['%s=%r' % (key, value)
14769 
      for key, value in self.__dict__.iteritems()]
14770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14771 
 
14772 
  def __eq__(self, other):
14773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14774 
 
14775 
  def __ne__(self, other):
14776 
    return not (self == other)
14777 
 
9155 kshitij.so 14778 
class getActiveBannersForMobileSite_args:
14779 
 
14780 
  thrift_spec = (
14781 
  )
14782 
 
14783 
  def read(self, iprot):
14784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14786 
      return
14787 
    iprot.readStructBegin()
14788 
    while True:
14789 
      (fname, ftype, fid) = iprot.readFieldBegin()
14790 
      if ftype == TType.STOP:
14791 
        break
14792 
      else:
14793 
        iprot.skip(ftype)
14794 
      iprot.readFieldEnd()
14795 
    iprot.readStructEnd()
14796 
 
14797 
  def write(self, oprot):
14798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14800 
      return
14801 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
14802 
    oprot.writeFieldStop()
14803 
    oprot.writeStructEnd()
14804 
 
14805 
  def validate(self):
14806 
    return
14807 
 
14808 
 
14809 
  def __repr__(self):
14810 
    L = ['%s=%r' % (key, value)
14811 
      for key, value in self.__dict__.iteritems()]
14812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14813 
 
14814 
  def __eq__(self, other):
14815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14816 
 
14817 
  def __ne__(self, other):
14818 
    return not (self == other)
14819 
 
14820 
class getActiveBannersForMobileSite_result:
14821 
  """
14822 
  Attributes:
14823 
   - success
14824 
  """
14825 
 
14826 
  thrift_spec = (
14827 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
14828 
  )
14829 
 
14830 
  def __init__(self, success=None,):
14831 
    self.success = success
14832 
 
14833 
  def read(self, iprot):
14834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14836 
      return
14837 
    iprot.readStructBegin()
14838 
    while True:
14839 
      (fname, ftype, fid) = iprot.readFieldBegin()
14840 
      if ftype == TType.STOP:
14841 
        break
14842 
      if fid == 0:
14843 
        if ftype == TType.MAP:
14844 
          self.success = {}
14845 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
14846 
          for _i264 in xrange(_size260):
14847 
            _key265 = iprot.readString();
14848 
            _val266 = []
14849 
            (_etype270, _size267) = iprot.readListBegin()
14850 
            for _i271 in xrange(_size267):
14851 
              _elem272 = Banner()
14852 
              _elem272.read(iprot)
14853 
              _val266.append(_elem272)
14854 
            iprot.readListEnd()
14855 
            self.success[_key265] = _val266
14856 
          iprot.readMapEnd()
14857 
        else:
14858 
          iprot.skip(ftype)
14859 
      else:
14860 
        iprot.skip(ftype)
14861 
      iprot.readFieldEnd()
14862 
    iprot.readStructEnd()
14863 
 
14864 
  def write(self, oprot):
14865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14867 
      return
14868 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
14869 
    if self.success is not None:
14870 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14871 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
14872 
      for kiter273,viter274 in self.success.items():
14873 
        oprot.writeString(kiter273)
14874 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
14875 
        for iter275 in viter274:
14876 
          iter275.write(oprot)
14877 
        oprot.writeListEnd()
14878 
      oprot.writeMapEnd()
14879 
      oprot.writeFieldEnd()
14880 
    oprot.writeFieldStop()
14881 
    oprot.writeStructEnd()
14882 
 
14883 
  def validate(self):
14884 
    return
14885 
 
14886 
 
14887 
  def __repr__(self):
14888 
    L = ['%s=%r' % (key, value)
14889 
      for key, value in self.__dict__.iteritems()]
14890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14891 
 
14892 
  def __eq__(self, other):
14893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14894 
 
14895 
  def __ne__(self, other):
14896 
    return not (self == other)
14897 
 
5944 mandeep.dh 14898 
class deleteSimilarItem_args:
14899 
  """
14900 
  Attributes:
14901 
   - itemId
14902 
   - catalogItemId
14903 
  """
14904 
 
14905 
  thrift_spec = (
14906 
    None, # 0
14907 
    (1, TType.I64, 'itemId', None, None, ), # 1
14908 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
14909 
  )
14910 
 
14911 
  def __init__(self, itemId=None, catalogItemId=None,):
14912 
    self.itemId = itemId
14913 
    self.catalogItemId = catalogItemId
14914 
 
14915 
  def read(self, iprot):
14916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14918 
      return
14919 
    iprot.readStructBegin()
14920 
    while True:
14921 
      (fname, ftype, fid) = iprot.readFieldBegin()
14922 
      if ftype == TType.STOP:
14923 
        break
14924 
      if fid == 1:
14925 
        if ftype == TType.I64:
14926 
          self.itemId = iprot.readI64();
14927 
        else:
14928 
          iprot.skip(ftype)
14929 
      elif fid == 2:
14930 
        if ftype == TType.I64:
14931 
          self.catalogItemId = iprot.readI64();
14932 
        else:
14933 
          iprot.skip(ftype)
14934 
      else:
14935 
        iprot.skip(ftype)
14936 
      iprot.readFieldEnd()
14937 
    iprot.readStructEnd()
14938 
 
14939 
  def write(self, oprot):
14940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14942 
      return
14943 
    oprot.writeStructBegin('deleteSimilarItem_args')
14944 
    if self.itemId is not None:
14945 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14946 
      oprot.writeI64(self.itemId)
14947 
      oprot.writeFieldEnd()
14948 
    if self.catalogItemId is not None:
14949 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
14950 
      oprot.writeI64(self.catalogItemId)
14951 
      oprot.writeFieldEnd()
14952 
    oprot.writeFieldStop()
14953 
    oprot.writeStructEnd()
14954 
 
14955 
  def validate(self):
14956 
    return
14957 
 
14958 
 
14959 
  def __repr__(self):
14960 
    L = ['%s=%r' % (key, value)
14961 
      for key, value in self.__dict__.iteritems()]
14962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14963 
 
14964 
  def __eq__(self, other):
14965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14966 
 
14967 
  def __ne__(self, other):
14968 
    return not (self == other)
14969 
 
14970 
class deleteSimilarItem_result:
14971 
  """
14972 
  Attributes:
14973 
   - success
14974 
   - cex
14975 
  """
14976 
 
14977 
  thrift_spec = (
14978 
    (0, TType.BOOL, 'success', None, None, ), # 0
14979 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14980 
  )
14981 
 
14982 
  def __init__(self, success=None, cex=None,):
14983 
    self.success = success
14984 
    self.cex = cex
14985 
 
14986 
  def read(self, iprot):
14987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14989 
      return
14990 
    iprot.readStructBegin()
14991 
    while True:
14992 
      (fname, ftype, fid) = iprot.readFieldBegin()
14993 
      if ftype == TType.STOP:
14994 
        break
14995 
      if fid == 0:
14996 
        if ftype == TType.BOOL:
14997 
          self.success = iprot.readBool();
14998 
        else:
14999 
          iprot.skip(ftype)
15000 
      elif fid == 1:
15001 
        if ftype == TType.STRUCT:
15002 
          self.cex = CatalogServiceException()
15003 
          self.cex.read(iprot)
15004 
        else:
15005 
          iprot.skip(ftype)
15006 
      else:
15007 
        iprot.skip(ftype)
15008 
      iprot.readFieldEnd()
15009 
    iprot.readStructEnd()
15010 
 
15011 
  def write(self, oprot):
15012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15014 
      return
15015 
    oprot.writeStructBegin('deleteSimilarItem_result')
15016 
    if self.success is not None:
15017 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15018 
      oprot.writeBool(self.success)
15019 
      oprot.writeFieldEnd()
15020 
    if self.cex is not None:
15021 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15022 
      self.cex.write(oprot)
15023 
      oprot.writeFieldEnd()
15024 
    oprot.writeFieldStop()
15025 
    oprot.writeStructEnd()
15026 
 
15027 
  def validate(self):
15028 
    return
15029 
 
15030 
 
15031 
  def __repr__(self):
15032 
    L = ['%s=%r' % (key, value)
15033 
      for key, value in self.__dict__.iteritems()]
15034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15035 
 
15036 
  def __eq__(self, other):
15037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15038 
 
15039 
  def __ne__(self, other):
15040 
    return not (self == other)
15041 
 
15042 
class checkSimilarItem_args:
15043 
  """
15044 
  Attributes:
15045 
   - brand
15046 
   - modelNumber
15047 
   - modelName
15048 
   - color
15049 
  """
15050 
 
15051 
  thrift_spec = (
15052 
    None, # 0
15053 
    (1, TType.STRING, 'brand', None, None, ), # 1
15054 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
15055 
    (3, TType.STRING, 'modelName', None, None, ), # 3
15056 
    (4, TType.STRING, 'color', None, None, ), # 4
15057 
  )
15058 
 
15059 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
15060 
    self.brand = brand
15061 
    self.modelNumber = modelNumber
15062 
    self.modelName = modelName
15063 
    self.color = color
15064 
 
15065 
  def read(self, iprot):
15066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15068 
      return
15069 
    iprot.readStructBegin()
15070 
    while True:
15071 
      (fname, ftype, fid) = iprot.readFieldBegin()
15072 
      if ftype == TType.STOP:
15073 
        break
15074 
      if fid == 1:
15075 
        if ftype == TType.STRING:
15076 
          self.brand = iprot.readString();
15077 
        else:
15078 
          iprot.skip(ftype)
15079 
      elif fid == 2:
15080 
        if ftype == TType.STRING:
15081 
          self.modelNumber = iprot.readString();
15082 
        else:
15083 
          iprot.skip(ftype)
15084 
      elif fid == 3:
15085 
        if ftype == TType.STRING:
15086 
          self.modelName = iprot.readString();
15087 
        else:
15088 
          iprot.skip(ftype)
15089 
      elif fid == 4:
15090 
        if ftype == TType.STRING:
15091 
          self.color = iprot.readString();
15092 
        else:
15093 
          iprot.skip(ftype)
15094 
      else:
15095 
        iprot.skip(ftype)
15096 
      iprot.readFieldEnd()
15097 
    iprot.readStructEnd()
15098 
 
15099 
  def write(self, oprot):
15100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15102 
      return
15103 
    oprot.writeStructBegin('checkSimilarItem_args')
15104 
    if self.brand is not None:
15105 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
15106 
      oprot.writeString(self.brand)
15107 
      oprot.writeFieldEnd()
15108 
    if self.modelNumber is not None:
15109 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
15110 
      oprot.writeString(self.modelNumber)
15111 
      oprot.writeFieldEnd()
15112 
    if self.modelName is not None:
15113 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
15114 
      oprot.writeString(self.modelName)
15115 
      oprot.writeFieldEnd()
15116 
    if self.color is not None:
15117 
      oprot.writeFieldBegin('color', TType.STRING, 4)
15118 
      oprot.writeString(self.color)
15119 
      oprot.writeFieldEnd()
15120 
    oprot.writeFieldStop()
15121 
    oprot.writeStructEnd()
15122 
 
15123 
  def validate(self):
15124 
    return
15125 
 
15126 
 
15127 
  def __repr__(self):
15128 
    L = ['%s=%r' % (key, value)
15129 
      for key, value in self.__dict__.iteritems()]
15130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15131 
 
15132 
  def __eq__(self, other):
15133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15134 
 
15135 
  def __ne__(self, other):
15136 
    return not (self == other)
15137 
 
15138 
class checkSimilarItem_result:
15139 
  """
15140 
  Attributes:
15141 
   - success
15142 
  """
15143 
 
15144 
  thrift_spec = (
15145 
    (0, TType.I64, 'success', None, None, ), # 0
15146 
  )
15147 
 
15148 
  def __init__(self, success=None,):
15149 
    self.success = success
15150 
 
15151 
  def read(self, iprot):
15152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15154 
      return
15155 
    iprot.readStructBegin()
15156 
    while True:
15157 
      (fname, ftype, fid) = iprot.readFieldBegin()
15158 
      if ftype == TType.STOP:
15159 
        break
15160 
      if fid == 0:
15161 
        if ftype == TType.I64:
15162 
          self.success = iprot.readI64();
15163 
        else:
15164 
          iprot.skip(ftype)
15165 
      else:
15166 
        iprot.skip(ftype)
15167 
      iprot.readFieldEnd()
15168 
    iprot.readStructEnd()
15169 
 
15170 
  def write(self, oprot):
15171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15173 
      return
15174 
    oprot.writeStructBegin('checkSimilarItem_result')
15175 
    if self.success is not None:
15176 
      oprot.writeFieldBegin('success', TType.I64, 0)
15177 
      oprot.writeI64(self.success)
15178 
      oprot.writeFieldEnd()
15179 
    oprot.writeFieldStop()
15180 
    oprot.writeStructEnd()
15181 
 
15182 
  def validate(self):
15183 
    return
15184 
 
15185 
 
15186 
  def __repr__(self):
15187 
    L = ['%s=%r' % (key, value)
15188 
      for key, value in self.__dict__.iteritems()]
15189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15190 
 
15191 
  def __eq__(self, other):
15192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15193 
 
15194 
  def __ne__(self, other):
15195 
    return not (self == other)
15196 
 
15197 
class validateRiskyStatus_args:
15198 
  """
15199 
  Attributes:
15200 
   - itemId
15201 
  """
15202 
 
15203 
  thrift_spec = (
15204 
    None, # 0
15205 
    (1, TType.I64, 'itemId', None, None, ), # 1
15206 
  )
15207 
 
15208 
  def __init__(self, itemId=None,):
15209 
    self.itemId = itemId
15210 
 
15211 
  def read(self, iprot):
15212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15214 
      return
15215 
    iprot.readStructBegin()
15216 
    while True:
15217 
      (fname, ftype, fid) = iprot.readFieldBegin()
15218 
      if ftype == TType.STOP:
15219 
        break
15220 
      if fid == 1:
15221 
        if ftype == TType.I64:
15222 
          self.itemId = iprot.readI64();
15223 
        else:
15224 
          iprot.skip(ftype)
15225 
      else:
15226 
        iprot.skip(ftype)
15227 
      iprot.readFieldEnd()
15228 
    iprot.readStructEnd()
15229 
 
15230 
  def write(self, oprot):
15231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15233 
      return
15234 
    oprot.writeStructBegin('validateRiskyStatus_args')
15235 
    if self.itemId is not None:
15236 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15237 
      oprot.writeI64(self.itemId)
15238 
      oprot.writeFieldEnd()
15239 
    oprot.writeFieldStop()
15240 
    oprot.writeStructEnd()
15241 
 
15242 
  def validate(self):
15243 
    return
15244 
 
15245 
 
15246 
  def __repr__(self):
15247 
    L = ['%s=%r' % (key, value)
15248 
      for key, value in self.__dict__.iteritems()]
15249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15250 
 
15251 
  def __eq__(self, other):
15252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15253 
 
15254 
  def __ne__(self, other):
15255 
    return not (self == other)
15256 
 
15257 
class validateRiskyStatus_result:
15258 
 
15259 
  thrift_spec = (
15260 
  )
15261 
 
15262 
  def read(self, iprot):
15263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15265 
      return
15266 
    iprot.readStructBegin()
15267 
    while True:
15268 
      (fname, ftype, fid) = iprot.readFieldBegin()
15269 
      if ftype == TType.STOP:
15270 
        break
15271 
      else:
15272 
        iprot.skip(ftype)
15273 
      iprot.readFieldEnd()
15274 
    iprot.readStructEnd()
15275 
 
15276 
  def write(self, oprot):
15277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15279 
      return
15280 
    oprot.writeStructBegin('validateRiskyStatus_result')
15281 
    oprot.writeFieldStop()
15282 
    oprot.writeStructEnd()
15283 
 
15284 
  def validate(self):
15285 
    return
15286 
 
15287 
 
15288 
  def __repr__(self):
15289 
    L = ['%s=%r' % (key, value)
15290 
      for key, value in self.__dict__.iteritems()]
15291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15292 
 
15293 
  def __eq__(self, other):
15294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15295 
 
15296 
  def __ne__(self, other):
15297 
    return not (self == other)
15298 
 
15299 
class changeItemRiskyFlag_args:
15300 
  """
15301 
  Attributes:
15302 
   - itemId
15303 
   - risky
15304 
  """
15305 
 
15306 
  thrift_spec = (
15307 
    None, # 0
15308 
    (1, TType.I64, 'itemId', None, None, ), # 1
15309 
    (2, TType.BOOL, 'risky', None, None, ), # 2
15310 
  )
15311 
 
15312 
  def __init__(self, itemId=None, risky=None,):
15313 
    self.itemId = itemId
15314 
    self.risky = risky
15315 
 
15316 
  def read(self, iprot):
15317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15319 
      return
15320 
    iprot.readStructBegin()
15321 
    while True:
15322 
      (fname, ftype, fid) = iprot.readFieldBegin()
15323 
      if ftype == TType.STOP:
15324 
        break
15325 
      if fid == 1:
15326 
        if ftype == TType.I64:
15327 
          self.itemId = iprot.readI64();
15328 
        else:
15329 
          iprot.skip(ftype)
15330 
      elif fid == 2:
15331 
        if ftype == TType.BOOL:
15332 
          self.risky = iprot.readBool();
15333 
        else:
15334 
          iprot.skip(ftype)
15335 
      else:
15336 
        iprot.skip(ftype)
15337 
      iprot.readFieldEnd()
15338 
    iprot.readStructEnd()
15339 
 
15340 
  def write(self, oprot):
15341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15343 
      return
15344 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
15345 
    if self.itemId is not None:
15346 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15347 
      oprot.writeI64(self.itemId)
15348 
      oprot.writeFieldEnd()
15349 
    if self.risky is not None:
15350 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
15351 
      oprot.writeBool(self.risky)
15352 
      oprot.writeFieldEnd()
15353 
    oprot.writeFieldStop()
15354 
    oprot.writeStructEnd()
15355 
 
15356 
  def validate(self):
15357 
    return
15358 
 
15359 
 
15360 
  def __repr__(self):
15361 
    L = ['%s=%r' % (key, value)
15362 
      for key, value in self.__dict__.iteritems()]
15363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15364 
 
15365 
  def __eq__(self, other):
15366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15367 
 
15368 
  def __ne__(self, other):
15369 
    return not (self == other)
15370 
 
15371 
class changeItemRiskyFlag_result:
15372 
 
15373 
  thrift_spec = (
15374 
  )
15375 
 
15376 
  def read(self, iprot):
15377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15379 
      return
15380 
    iprot.readStructBegin()
15381 
    while True:
15382 
      (fname, ftype, fid) = iprot.readFieldBegin()
15383 
      if ftype == TType.STOP:
15384 
        break
15385 
      else:
15386 
        iprot.skip(ftype)
15387 
      iprot.readFieldEnd()
15388 
    iprot.readStructEnd()
15389 
 
15390 
  def write(self, oprot):
15391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15393 
      return
15394 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
15395 
    oprot.writeFieldStop()
15396 
    oprot.writeStructEnd()
15397 
 
15398 
  def validate(self):
15399 
    return
15400 
 
15401 
 
15402 
  def __repr__(self):
15403 
    L = ['%s=%r' % (key, value)
15404 
      for key, value in self.__dict__.iteritems()]
15405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15406 
 
15407 
  def __eq__(self, other):
15408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15409 
 
15410 
  def __ne__(self, other):
15411 
    return not (self == other)
15412 
 
15413 
class getItemsByRiskyFlag_args:
15414 
 
15415 
  thrift_spec = (
15416 
  )
15417 
 
15418 
  def read(self, iprot):
15419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15421 
      return
15422 
    iprot.readStructBegin()
15423 
    while True:
15424 
      (fname, ftype, fid) = iprot.readFieldBegin()
15425 
      if ftype == TType.STOP:
15426 
        break
15427 
      else:
15428 
        iprot.skip(ftype)
15429 
      iprot.readFieldEnd()
15430 
    iprot.readStructEnd()
15431 
 
15432 
  def write(self, oprot):
15433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15435 
      return
15436 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
15437 
    oprot.writeFieldStop()
15438 
    oprot.writeStructEnd()
15439 
 
15440 
  def validate(self):
15441 
    return
15442 
 
15443 
 
15444 
  def __repr__(self):
15445 
    L = ['%s=%r' % (key, value)
15446 
      for key, value in self.__dict__.iteritems()]
15447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15448 
 
15449 
  def __eq__(self, other):
15450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15451 
 
15452 
  def __ne__(self, other):
15453 
    return not (self == other)
15454 
 
15455 
class getItemsByRiskyFlag_result:
15456 
  """
15457 
  Attributes:
15458 
   - success
15459 
  """
15460 
 
15461 
  thrift_spec = (
15462 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15463 
  )
15464 
 
15465 
  def __init__(self, success=None,):
15466 
    self.success = success
15467 
 
15468 
  def read(self, iprot):
15469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15471 
      return
15472 
    iprot.readStructBegin()
15473 
    while True:
15474 
      (fname, ftype, fid) = iprot.readFieldBegin()
15475 
      if ftype == TType.STOP:
15476 
        break
15477 
      if fid == 0:
15478 
        if ftype == TType.LIST:
15479 
          self.success = []
9155 kshitij.so 15480 
          (_etype279, _size276) = iprot.readListBegin()
15481 
          for _i280 in xrange(_size276):
15482 
            _elem281 = Item()
15483 
            _elem281.read(iprot)
15484 
            self.success.append(_elem281)
5944 mandeep.dh 15485 
          iprot.readListEnd()
15486 
        else:
15487 
          iprot.skip(ftype)
15488 
      else:
15489 
        iprot.skip(ftype)
15490 
      iprot.readFieldEnd()
15491 
    iprot.readStructEnd()
15492 
 
15493 
  def write(self, oprot):
15494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15496 
      return
15497 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
15498 
    if self.success is not None:
15499 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15500 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15501 
      for iter282 in self.success:
15502 
        iter282.write(oprot)
5944 mandeep.dh 15503 
      oprot.writeListEnd()
15504 
      oprot.writeFieldEnd()
15505 
    oprot.writeFieldStop()
15506 
    oprot.writeStructEnd()
15507 
 
15508 
  def validate(self):
15509 
    return
15510 
 
15511 
 
15512 
  def __repr__(self):
15513 
    L = ['%s=%r' % (key, value)
15514 
      for key, value in self.__dict__.iteritems()]
15515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15516 
 
15517 
  def __eq__(self, other):
15518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15519 
 
15520 
  def __ne__(self, other):
15521 
    return not (self == other)
15522 
 
15523 
class getItemsForMasterSheet_args:
15524 
  """
15525 
  Attributes:
15526 
   - category
15527 
   - brand
15528 
  """
15529 
 
15530 
  thrift_spec = (
15531 
    None, # 0
15532 
    (1, TType.STRING, 'category', None, None, ), # 1
15533 
    (2, TType.STRING, 'brand', None, None, ), # 2
15534 
  )
15535 
 
15536 
  def __init__(self, category=None, brand=None,):
15537 
    self.category = category
15538 
    self.brand = brand
15539 
 
15540 
  def read(self, iprot):
15541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15543 
      return
15544 
    iprot.readStructBegin()
15545 
    while True:
15546 
      (fname, ftype, fid) = iprot.readFieldBegin()
15547 
      if ftype == TType.STOP:
15548 
        break
15549 
      if fid == 1:
15550 
        if ftype == TType.STRING:
15551 
          self.category = iprot.readString();
15552 
        else:
15553 
          iprot.skip(ftype)
15554 
      elif fid == 2:
15555 
        if ftype == TType.STRING:
15556 
          self.brand = iprot.readString();
15557 
        else:
15558 
          iprot.skip(ftype)
15559 
      else:
15560 
        iprot.skip(ftype)
15561 
      iprot.readFieldEnd()
15562 
    iprot.readStructEnd()
15563 
 
15564 
  def write(self, oprot):
15565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15567 
      return
15568 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
15569 
    if self.category is not None:
15570 
      oprot.writeFieldBegin('category', TType.STRING, 1)
15571 
      oprot.writeString(self.category)
15572 
      oprot.writeFieldEnd()
15573 
    if self.brand is not None:
15574 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
15575 
      oprot.writeString(self.brand)
15576 
      oprot.writeFieldEnd()
15577 
    oprot.writeFieldStop()
15578 
    oprot.writeStructEnd()
15579 
 
15580 
  def validate(self):
15581 
    return
15582 
 
15583 
 
15584 
  def __repr__(self):
15585 
    L = ['%s=%r' % (key, value)
15586 
      for key, value in self.__dict__.iteritems()]
15587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15588 
 
15589 
  def __eq__(self, other):
15590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15591 
 
15592 
  def __ne__(self, other):
15593 
    return not (self == other)
15594 
 
15595 
class getItemsForMasterSheet_result:
15596 
  """
15597 
  Attributes:
15598 
   - success
15599 
  """
15600 
 
15601 
  thrift_spec = (
15602 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15603 
  )
15604 
 
15605 
  def __init__(self, success=None,):
15606 
    self.success = success
15607 
 
15608 
  def read(self, iprot):
15609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15611 
      return
15612 
    iprot.readStructBegin()
15613 
    while True:
15614 
      (fname, ftype, fid) = iprot.readFieldBegin()
15615 
      if ftype == TType.STOP:
15616 
        break
15617 
      if fid == 0:
15618 
        if ftype == TType.LIST:
15619 
          self.success = []
9155 kshitij.so 15620 
          (_etype286, _size283) = iprot.readListBegin()
15621 
          for _i287 in xrange(_size283):
15622 
            _elem288 = Item()
15623 
            _elem288.read(iprot)
15624 
            self.success.append(_elem288)
5944 mandeep.dh 15625 
          iprot.readListEnd()
15626 
        else:
15627 
          iprot.skip(ftype)
15628 
      else:
15629 
        iprot.skip(ftype)
15630 
      iprot.readFieldEnd()
15631 
    iprot.readStructEnd()
15632 
 
15633 
  def write(self, oprot):
15634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15636 
      return
15637 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
15638 
    if self.success is not None:
15639 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15640 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15641 
      for iter289 in self.success:
15642 
        iter289.write(oprot)
5944 mandeep.dh 15643 
      oprot.writeListEnd()
15644 
      oprot.writeFieldEnd()
15645 
    oprot.writeFieldStop()
15646 
    oprot.writeStructEnd()
15647 
 
15648 
  def validate(self):
15649 
    return
15650 
 
15651 
 
15652 
  def __repr__(self):
15653 
    L = ['%s=%r' % (key, value)
15654 
      for key, value in self.__dict__.iteritems()]
15655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15656 
 
15657 
  def __eq__(self, other):
15658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15659 
 
15660 
  def __ne__(self, other):
15661 
    return not (self == other)
15662 
 
15663 
class getSimilarItemsCatalogIds_args:
15664 
  """
15665 
  Attributes:
15666 
   - beginIndex
15667 
   - totalItems
15668 
   - itemId
15669 
  """
15670 
 
15671 
  thrift_spec = (
15672 
    None, # 0
15673 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
15674 
    (2, TType.I64, 'totalItems', None, None, ), # 2
15675 
    (3, TType.I64, 'itemId', None, None, ), # 3
15676 
  )
15677 
 
15678 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
15679 
    self.beginIndex = beginIndex
15680 
    self.totalItems = totalItems
15681 
    self.itemId = itemId
15682 
 
15683 
  def read(self, iprot):
15684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15686 
      return
15687 
    iprot.readStructBegin()
15688 
    while True:
15689 
      (fname, ftype, fid) = iprot.readFieldBegin()
15690 
      if ftype == TType.STOP:
15691 
        break
15692 
      if fid == 1:
15693 
        if ftype == TType.I64:
15694 
          self.beginIndex = iprot.readI64();
15695 
        else:
15696 
          iprot.skip(ftype)
15697 
      elif fid == 2:
15698 
        if ftype == TType.I64:
15699 
          self.totalItems = iprot.readI64();
15700 
        else:
15701 
          iprot.skip(ftype)
15702 
      elif fid == 3:
15703 
        if ftype == TType.I64:
15704 
          self.itemId = iprot.readI64();
15705 
        else:
15706 
          iprot.skip(ftype)
15707 
      else:
15708 
        iprot.skip(ftype)
15709 
      iprot.readFieldEnd()
15710 
    iprot.readStructEnd()
15711 
 
15712 
  def write(self, oprot):
15713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15715 
      return
15716 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
15717 
    if self.beginIndex is not None:
15718 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
15719 
      oprot.writeI64(self.beginIndex)
15720 
      oprot.writeFieldEnd()
15721 
    if self.totalItems is not None:
15722 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
15723 
      oprot.writeI64(self.totalItems)
15724 
      oprot.writeFieldEnd()
15725 
    if self.itemId is not None:
15726 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
15727 
      oprot.writeI64(self.itemId)
15728 
      oprot.writeFieldEnd()
15729 
    oprot.writeFieldStop()
15730 
    oprot.writeStructEnd()
15731 
 
15732 
  def validate(self):
15733 
    return
15734 
 
15735 
 
15736 
  def __repr__(self):
15737 
    L = ['%s=%r' % (key, value)
15738 
      for key, value in self.__dict__.iteritems()]
15739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15740 
 
15741 
  def __eq__(self, other):
15742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15743 
 
15744 
  def __ne__(self, other):
15745 
    return not (self == other)
15746 
 
15747 
class getSimilarItemsCatalogIds_result:
15748 
  """
15749 
  Attributes:
15750 
   - success
15751 
  """
15752 
 
15753 
  thrift_spec = (
15754 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15755 
  )
15756 
 
15757 
  def __init__(self, success=None,):
15758 
    self.success = success
15759 
 
15760 
  def read(self, iprot):
15761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15763 
      return
15764 
    iprot.readStructBegin()
15765 
    while True:
15766 
      (fname, ftype, fid) = iprot.readFieldBegin()
15767 
      if ftype == TType.STOP:
15768 
        break
15769 
      if fid == 0:
15770 
        if ftype == TType.LIST:
15771 
          self.success = []
9155 kshitij.so 15772 
          (_etype293, _size290) = iprot.readListBegin()
15773 
          for _i294 in xrange(_size290):
15774 
            _elem295 = iprot.readI64();
15775 
            self.success.append(_elem295)
5944 mandeep.dh 15776 
          iprot.readListEnd()
15777 
        else:
15778 
          iprot.skip(ftype)
15779 
      else:
15780 
        iprot.skip(ftype)
15781 
      iprot.readFieldEnd()
15782 
    iprot.readStructEnd()
15783 
 
15784 
  def write(self, oprot):
15785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15787 
      return
15788 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
15789 
    if self.success is not None:
15790 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15791 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 15792 
      for iter296 in self.success:
15793 
        oprot.writeI64(iter296)
5944 mandeep.dh 15794 
      oprot.writeListEnd()
15795 
      oprot.writeFieldEnd()
15796 
    oprot.writeFieldStop()
15797 
    oprot.writeStructEnd()
15798 
 
15799 
  def validate(self):
15800 
    return
15801 
 
15802 
 
15803 
  def __repr__(self):
15804 
    L = ['%s=%r' % (key, value)
15805 
      for key, value in self.__dict__.iteritems()]
15806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15807 
 
15808 
  def __eq__(self, other):
15809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15810 
 
15811 
  def __ne__(self, other):
15812 
    return not (self == other)
15813 
 
15814 
class addProductNotification_args:
15815 
  """
15816 
  Attributes:
15817 
   - itemId
15818 
   - email
15819 
  """
15820 
 
15821 
  thrift_spec = None
15822 
  def __init__(self, itemId=None, email=None,):
15823 
    self.itemId = itemId
15824 
    self.email = email
15825 
 
15826 
  def read(self, iprot):
15827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15829 
      return
15830 
    iprot.readStructBegin()
15831 
    while True:
15832 
      (fname, ftype, fid) = iprot.readFieldBegin()
15833 
      if ftype == TType.STOP:
15834 
        break
15835 
      if fid == -1:
15836 
        if ftype == TType.I64:
15837 
          self.itemId = iprot.readI64();
15838 
        else:
15839 
          iprot.skip(ftype)
15840 
      elif fid == -2:
15841 
        if ftype == TType.STRING:
15842 
          self.email = iprot.readString();
15843 
        else:
15844 
          iprot.skip(ftype)
15845 
      else:
15846 
        iprot.skip(ftype)
15847 
      iprot.readFieldEnd()
15848 
    iprot.readStructEnd()
15849 
 
15850 
  def write(self, oprot):
15851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15853 
      return
15854 
    oprot.writeStructBegin('addProductNotification_args')
15855 
    if self.email is not None:
15856 
      oprot.writeFieldBegin('email', TType.STRING, -2)
15857 
      oprot.writeString(self.email)
15858 
      oprot.writeFieldEnd()
15859 
    if self.itemId is not None:
15860 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
15861 
      oprot.writeI64(self.itemId)
15862 
      oprot.writeFieldEnd()
15863 
    oprot.writeFieldStop()
15864 
    oprot.writeStructEnd()
15865 
 
15866 
  def validate(self):
15867 
    return
15868 
 
15869 
 
15870 
  def __repr__(self):
15871 
    L = ['%s=%r' % (key, value)
15872 
      for key, value in self.__dict__.iteritems()]
15873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15874 
 
15875 
  def __eq__(self, other):
15876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15877 
 
15878 
  def __ne__(self, other):
15879 
    return not (self == other)
15880 
 
15881 
class addProductNotification_result:
15882 
  """
15883 
  Attributes:
15884 
   - success
15885 
  """
15886 
 
15887 
  thrift_spec = (
15888 
    (0, TType.BOOL, 'success', None, None, ), # 0
15889 
  )
15890 
 
15891 
  def __init__(self, success=None,):
15892 
    self.success = success
15893 
 
15894 
  def read(self, iprot):
15895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15897 
      return
15898 
    iprot.readStructBegin()
15899 
    while True:
15900 
      (fname, ftype, fid) = iprot.readFieldBegin()
15901 
      if ftype == TType.STOP:
15902 
        break
15903 
      if fid == 0:
15904 
        if ftype == TType.BOOL:
15905 
          self.success = iprot.readBool();
15906 
        else:
15907 
          iprot.skip(ftype)
15908 
      else:
15909 
        iprot.skip(ftype)
15910 
      iprot.readFieldEnd()
15911 
    iprot.readStructEnd()
15912 
 
15913 
  def write(self, oprot):
15914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15916 
      return
15917 
    oprot.writeStructBegin('addProductNotification_result')
15918 
    if self.success is not None:
15919 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15920 
      oprot.writeBool(self.success)
15921 
      oprot.writeFieldEnd()
15922 
    oprot.writeFieldStop()
15923 
    oprot.writeStructEnd()
15924 
 
15925 
  def validate(self):
15926 
    return
15927 
 
15928 
 
15929 
  def __repr__(self):
15930 
    L = ['%s=%r' % (key, value)
15931 
      for key, value in self.__dict__.iteritems()]
15932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15933 
 
15934 
  def __eq__(self, other):
15935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15936 
 
15937 
  def __ne__(self, other):
15938 
    return not (self == other)
15939 
 
15940 
class sendProductNotifications_args:
15941 
 
15942 
  thrift_spec = (
15943 
  )
15944 
 
15945 
  def read(self, iprot):
15946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15948 
      return
15949 
    iprot.readStructBegin()
15950 
    while True:
15951 
      (fname, ftype, fid) = iprot.readFieldBegin()
15952 
      if ftype == TType.STOP:
15953 
        break
15954 
      else:
15955 
        iprot.skip(ftype)
15956 
      iprot.readFieldEnd()
15957 
    iprot.readStructEnd()
15958 
 
15959 
  def write(self, oprot):
15960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15962 
      return
15963 
    oprot.writeStructBegin('sendProductNotifications_args')
15964 
    oprot.writeFieldStop()
15965 
    oprot.writeStructEnd()
15966 
 
15967 
  def validate(self):
15968 
    return
15969 
 
15970 
 
15971 
  def __repr__(self):
15972 
    L = ['%s=%r' % (key, value)
15973 
      for key, value in self.__dict__.iteritems()]
15974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15975 
 
15976 
  def __eq__(self, other):
15977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15978 
 
15979 
  def __ne__(self, other):
15980 
    return not (self == other)
15981 
 
15982 
class sendProductNotifications_result:
15983 
  """
15984 
  Attributes:
15985 
   - success
15986 
  """
15987 
 
15988 
  thrift_spec = (
15989 
    (0, TType.BOOL, 'success', None, None, ), # 0
15990 
  )
15991 
 
15992 
  def __init__(self, success=None,):
15993 
    self.success = success
15994 
 
15995 
  def read(self, iprot):
15996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15998 
      return
15999 
    iprot.readStructBegin()
16000 
    while True:
16001 
      (fname, ftype, fid) = iprot.readFieldBegin()
16002 
      if ftype == TType.STOP:
16003 
        break
16004 
      if fid == 0:
16005 
        if ftype == TType.BOOL:
16006 
          self.success = iprot.readBool();
16007 
        else:
16008 
          iprot.skip(ftype)
16009 
      else:
16010 
        iprot.skip(ftype)
16011 
      iprot.readFieldEnd()
16012 
    iprot.readStructEnd()
16013 
 
16014 
  def write(self, oprot):
16015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16017 
      return
16018 
    oprot.writeStructBegin('sendProductNotifications_result')
16019 
    if self.success is not None:
16020 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16021 
      oprot.writeBool(self.success)
16022 
      oprot.writeFieldEnd()
16023 
    oprot.writeFieldStop()
16024 
    oprot.writeStructEnd()
16025 
 
16026 
  def validate(self):
16027 
    return
16028 
 
16029 
 
16030 
  def __repr__(self):
16031 
    L = ['%s=%r' % (key, value)
16032 
      for key, value in self.__dict__.iteritems()]
16033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16034 
 
16035 
  def __eq__(self, other):
16036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16037 
 
16038 
  def __ne__(self, other):
16039 
    return not (self == other)
16040 
 
16041 
class getAllBrandsByCategory_args:
16042 
  """
16043 
  Attributes:
16044 
   - categoryId
16045 
  """
16046 
 
16047 
  thrift_spec = (
16048 
    None, # 0
16049 
    (1, TType.I64, 'categoryId', None, None, ), # 1
16050 
  )
16051 
 
16052 
  def __init__(self, categoryId=None,):
16053 
    self.categoryId = categoryId
16054 
 
16055 
  def read(self, iprot):
16056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16058 
      return
16059 
    iprot.readStructBegin()
16060 
    while True:
16061 
      (fname, ftype, fid) = iprot.readFieldBegin()
16062 
      if ftype == TType.STOP:
16063 
        break
16064 
      if fid == 1:
16065 
        if ftype == TType.I64:
16066 
          self.categoryId = iprot.readI64();
16067 
        else:
16068 
          iprot.skip(ftype)
16069 
      else:
16070 
        iprot.skip(ftype)
16071 
      iprot.readFieldEnd()
16072 
    iprot.readStructEnd()
16073 
 
16074 
  def write(self, oprot):
16075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16077 
      return
16078 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
16079 
    if self.categoryId is not None:
16080 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
16081 
      oprot.writeI64(self.categoryId)
16082 
      oprot.writeFieldEnd()
16083 
    oprot.writeFieldStop()
16084 
    oprot.writeStructEnd()
16085 
 
16086 
  def validate(self):
16087 
    return
16088 
 
16089 
 
16090 
  def __repr__(self):
16091 
    L = ['%s=%r' % (key, value)
16092 
      for key, value in self.__dict__.iteritems()]
16093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16094 
 
16095 
  def __eq__(self, other):
16096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16097 
 
16098 
  def __ne__(self, other):
16099 
    return not (self == other)
16100 
 
16101 
class getAllBrandsByCategory_result:
16102 
  """
16103 
  Attributes:
16104 
   - success
16105 
  """
16106 
 
16107 
  thrift_spec = (
16108 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16109 
  )
16110 
 
16111 
  def __init__(self, success=None,):
16112 
    self.success = success
16113 
 
16114 
  def read(self, iprot):
16115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16117 
      return
16118 
    iprot.readStructBegin()
16119 
    while True:
16120 
      (fname, ftype, fid) = iprot.readFieldBegin()
16121 
      if ftype == TType.STOP:
16122 
        break
16123 
      if fid == 0:
16124 
        if ftype == TType.LIST:
16125 
          self.success = []
9155 kshitij.so 16126 
          (_etype300, _size297) = iprot.readListBegin()
16127 
          for _i301 in xrange(_size297):
16128 
            _elem302 = iprot.readString();
16129 
            self.success.append(_elem302)
5944 mandeep.dh 16130 
          iprot.readListEnd()
16131 
        else:
16132 
          iprot.skip(ftype)
16133 
      else:
16134 
        iprot.skip(ftype)
16135 
      iprot.readFieldEnd()
16136 
    iprot.readStructEnd()
16137 
 
16138 
  def write(self, oprot):
16139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16141 
      return
16142 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
16143 
    if self.success is not None:
16144 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16145 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16146 
      for iter303 in self.success:
16147 
        oprot.writeString(iter303)
5944 mandeep.dh 16148 
      oprot.writeListEnd()
16149 
      oprot.writeFieldEnd()
16150 
    oprot.writeFieldStop()
16151 
    oprot.writeStructEnd()
16152 
 
16153 
  def validate(self):
16154 
    return
16155 
 
16156 
 
16157 
  def __repr__(self):
16158 
    L = ['%s=%r' % (key, value)
16159 
      for key, value in self.__dict__.iteritems()]
16160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16161 
 
16162 
  def __eq__(self, other):
16163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16164 
 
16165 
  def __ne__(self, other):
16166 
    return not (self == other)
16167 
 
16168 
class getAllBrands_args:
16169 
 
16170 
  thrift_spec = (
16171 
  )
16172 
 
16173 
  def read(self, iprot):
16174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16176 
      return
16177 
    iprot.readStructBegin()
16178 
    while True:
16179 
      (fname, ftype, fid) = iprot.readFieldBegin()
16180 
      if ftype == TType.STOP:
16181 
        break
16182 
      else:
16183 
        iprot.skip(ftype)
16184 
      iprot.readFieldEnd()
16185 
    iprot.readStructEnd()
16186 
 
16187 
  def write(self, oprot):
16188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16190 
      return
16191 
    oprot.writeStructBegin('getAllBrands_args')
16192 
    oprot.writeFieldStop()
16193 
    oprot.writeStructEnd()
16194 
 
16195 
  def validate(self):
16196 
    return
16197 
 
16198 
 
16199 
  def __repr__(self):
16200 
    L = ['%s=%r' % (key, value)
16201 
      for key, value in self.__dict__.iteritems()]
16202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16203 
 
16204 
  def __eq__(self, other):
16205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16206 
 
16207 
  def __ne__(self, other):
16208 
    return not (self == other)
16209 
 
16210 
class getAllBrands_result:
16211 
  """
16212 
  Attributes:
16213 
   - success
16214 
  """
16215 
 
16216 
  thrift_spec = (
16217 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16218 
  )
16219 
 
16220 
  def __init__(self, success=None,):
16221 
    self.success = success
16222 
 
16223 
  def read(self, iprot):
16224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16226 
      return
16227 
    iprot.readStructBegin()
16228 
    while True:
16229 
      (fname, ftype, fid) = iprot.readFieldBegin()
16230 
      if ftype == TType.STOP:
16231 
        break
16232 
      if fid == 0:
16233 
        if ftype == TType.LIST:
16234 
          self.success = []
9155 kshitij.so 16235 
          (_etype307, _size304) = iprot.readListBegin()
16236 
          for _i308 in xrange(_size304):
16237 
            _elem309 = iprot.readString();
16238 
            self.success.append(_elem309)
5944 mandeep.dh 16239 
          iprot.readListEnd()
16240 
        else:
16241 
          iprot.skip(ftype)
16242 
      else:
16243 
        iprot.skip(ftype)
16244 
      iprot.readFieldEnd()
16245 
    iprot.readStructEnd()
16246 
 
16247 
  def write(self, oprot):
16248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16250 
      return
16251 
    oprot.writeStructBegin('getAllBrands_result')
16252 
    if self.success is not None:
16253 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16254 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16255 
      for iter310 in self.success:
16256 
        oprot.writeString(iter310)
5944 mandeep.dh 16257 
      oprot.writeListEnd()
16258 
      oprot.writeFieldEnd()
16259 
    oprot.writeFieldStop()
16260 
    oprot.writeStructEnd()
16261 
 
16262 
  def validate(self):
16263 
    return
16264 
 
16265 
 
16266 
  def __repr__(self):
16267 
    L = ['%s=%r' % (key, value)
16268 
      for key, value in self.__dict__.iteritems()]
16269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16270 
 
16271 
  def __eq__(self, other):
16272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16273 
 
16274 
  def __ne__(self, other):
16275 
    return not (self == other)
16276 
 
16277 
class getAllSources_args:
16278 
 
16279 
  thrift_spec = (
16280 
  )
16281 
 
16282 
  def read(self, iprot):
16283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16285 
      return
16286 
    iprot.readStructBegin()
16287 
    while True:
16288 
      (fname, ftype, fid) = iprot.readFieldBegin()
16289 
      if ftype == TType.STOP:
16290 
        break
16291 
      else:
16292 
        iprot.skip(ftype)
16293 
      iprot.readFieldEnd()
16294 
    iprot.readStructEnd()
16295 
 
16296 
  def write(self, oprot):
16297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16299 
      return
16300 
    oprot.writeStructBegin('getAllSources_args')
16301 
    oprot.writeFieldStop()
16302 
    oprot.writeStructEnd()
16303 
 
16304 
  def validate(self):
16305 
    return
16306 
 
16307 
 
16308 
  def __repr__(self):
16309 
    L = ['%s=%r' % (key, value)
16310 
      for key, value in self.__dict__.iteritems()]
16311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16312 
 
16313 
  def __eq__(self, other):
16314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16315 
 
16316 
  def __ne__(self, other):
16317 
    return not (self == other)
16318 
 
16319 
class getAllSources_result:
16320 
  """
16321 
  Attributes:
16322 
   - success
16323 
  """
16324 
 
16325 
  thrift_spec = (
16326 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
16327 
  )
16328 
 
16329 
  def __init__(self, success=None,):
16330 
    self.success = success
16331 
 
16332 
  def read(self, iprot):
16333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16335 
      return
16336 
    iprot.readStructBegin()
16337 
    while True:
16338 
      (fname, ftype, fid) = iprot.readFieldBegin()
16339 
      if ftype == TType.STOP:
16340 
        break
16341 
      if fid == 0:
16342 
        if ftype == TType.LIST:
16343 
          self.success = []
9155 kshitij.so 16344 
          (_etype314, _size311) = iprot.readListBegin()
16345 
          for _i315 in xrange(_size311):
16346 
            _elem316 = Source()
16347 
            _elem316.read(iprot)
16348 
            self.success.append(_elem316)
5944 mandeep.dh 16349 
          iprot.readListEnd()
16350 
        else:
16351 
          iprot.skip(ftype)
16352 
      else:
16353 
        iprot.skip(ftype)
16354 
      iprot.readFieldEnd()
16355 
    iprot.readStructEnd()
16356 
 
16357 
  def write(self, oprot):
16358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16360 
      return
16361 
    oprot.writeStructBegin('getAllSources_result')
16362 
    if self.success is not None:
16363 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16364 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16365 
      for iter317 in self.success:
16366 
        iter317.write(oprot)
5944 mandeep.dh 16367 
      oprot.writeListEnd()
16368 
      oprot.writeFieldEnd()
16369 
    oprot.writeFieldStop()
16370 
    oprot.writeStructEnd()
16371 
 
16372 
  def validate(self):
16373 
    return
16374 
 
16375 
 
16376 
  def __repr__(self):
16377 
    L = ['%s=%r' % (key, value)
16378 
      for key, value in self.__dict__.iteritems()]
16379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16380 
 
16381 
  def __eq__(self, other):
16382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16383 
 
16384 
  def __ne__(self, other):
16385 
    return not (self == other)
16386 
 
16387 
class getItemPricingBySource_args:
16388 
  """
16389 
  Attributes:
16390 
   - itemId
16391 
   - sourceId
16392 
  """
16393 
 
16394 
  thrift_spec = (
16395 
    None, # 0
16396 
    (1, TType.I64, 'itemId', None, None, ), # 1
16397 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16398 
  )
16399 
 
16400 
  def __init__(self, itemId=None, sourceId=None,):
16401 
    self.itemId = itemId
16402 
    self.sourceId = sourceId
16403 
 
16404 
  def read(self, iprot):
16405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16407 
      return
16408 
    iprot.readStructBegin()
16409 
    while True:
16410 
      (fname, ftype, fid) = iprot.readFieldBegin()
16411 
      if ftype == TType.STOP:
16412 
        break
16413 
      if fid == 1:
16414 
        if ftype == TType.I64:
16415 
          self.itemId = iprot.readI64();
16416 
        else:
16417 
          iprot.skip(ftype)
16418 
      elif fid == 2:
16419 
        if ftype == TType.I64:
16420 
          self.sourceId = iprot.readI64();
16421 
        else:
16422 
          iprot.skip(ftype)
16423 
      else:
16424 
        iprot.skip(ftype)
16425 
      iprot.readFieldEnd()
16426 
    iprot.readStructEnd()
16427 
 
16428 
  def write(self, oprot):
16429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16431 
      return
16432 
    oprot.writeStructBegin('getItemPricingBySource_args')
16433 
    if self.itemId is not None:
16434 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16435 
      oprot.writeI64(self.itemId)
16436 
      oprot.writeFieldEnd()
16437 
    if self.sourceId is not None:
16438 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16439 
      oprot.writeI64(self.sourceId)
16440 
      oprot.writeFieldEnd()
16441 
    oprot.writeFieldStop()
16442 
    oprot.writeStructEnd()
16443 
 
16444 
  def validate(self):
16445 
    return
16446 
 
16447 
 
16448 
  def __repr__(self):
16449 
    L = ['%s=%r' % (key, value)
16450 
      for key, value in self.__dict__.iteritems()]
16451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16452 
 
16453 
  def __eq__(self, other):
16454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16455 
 
16456 
  def __ne__(self, other):
16457 
    return not (self == other)
16458 
 
16459 
class getItemPricingBySource_result:
16460 
  """
16461 
  Attributes:
16462 
   - success
16463 
   - cex
16464 
  """
16465 
 
16466 
  thrift_spec = (
16467 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
16468 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16469 
  )
16470 
 
16471 
  def __init__(self, success=None, cex=None,):
16472 
    self.success = success
16473 
    self.cex = cex
16474 
 
16475 
  def read(self, iprot):
16476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16478 
      return
16479 
    iprot.readStructBegin()
16480 
    while True:
16481 
      (fname, ftype, fid) = iprot.readFieldBegin()
16482 
      if ftype == TType.STOP:
16483 
        break
16484 
      if fid == 0:
16485 
        if ftype == TType.STRUCT:
16486 
          self.success = SourceItemPricing()
16487 
          self.success.read(iprot)
16488 
        else:
16489 
          iprot.skip(ftype)
16490 
      elif fid == 1:
16491 
        if ftype == TType.STRUCT:
16492 
          self.cex = CatalogServiceException()
16493 
          self.cex.read(iprot)
16494 
        else:
16495 
          iprot.skip(ftype)
16496 
      else:
16497 
        iprot.skip(ftype)
16498 
      iprot.readFieldEnd()
16499 
    iprot.readStructEnd()
16500 
 
16501 
  def write(self, oprot):
16502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16504 
      return
16505 
    oprot.writeStructBegin('getItemPricingBySource_result')
16506 
    if self.success is not None:
16507 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16508 
      self.success.write(oprot)
16509 
      oprot.writeFieldEnd()
16510 
    if self.cex is not None:
16511 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16512 
      self.cex.write(oprot)
16513 
      oprot.writeFieldEnd()
16514 
    oprot.writeFieldStop()
16515 
    oprot.writeStructEnd()
16516 
 
16517 
  def validate(self):
16518 
    return
16519 
 
16520 
 
16521 
  def __repr__(self):
16522 
    L = ['%s=%r' % (key, value)
16523 
      for key, value in self.__dict__.iteritems()]
16524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16525 
 
16526 
  def __eq__(self, other):
16527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16528 
 
16529 
  def __ne__(self, other):
16530 
    return not (self == other)
16531 
 
16532 
class addSourceItemPricing_args:
16533 
  """
16534 
  Attributes:
16535 
   - sourceItemPricing
16536 
  """
16537 
 
16538 
  thrift_spec = (
16539 
    None, # 0
16540 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
16541 
  )
16542 
 
16543 
  def __init__(self, sourceItemPricing=None,):
16544 
    self.sourceItemPricing = sourceItemPricing
16545 
 
16546 
  def read(self, iprot):
16547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16549 
      return
16550 
    iprot.readStructBegin()
16551 
    while True:
16552 
      (fname, ftype, fid) = iprot.readFieldBegin()
16553 
      if ftype == TType.STOP:
16554 
        break
16555 
      if fid == 1:
16556 
        if ftype == TType.STRUCT:
16557 
          self.sourceItemPricing = SourceItemPricing()
16558 
          self.sourceItemPricing.read(iprot)
16559 
        else:
16560 
          iprot.skip(ftype)
16561 
      else:
16562 
        iprot.skip(ftype)
16563 
      iprot.readFieldEnd()
16564 
    iprot.readStructEnd()
16565 
 
16566 
  def write(self, oprot):
16567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16569 
      return
16570 
    oprot.writeStructBegin('addSourceItemPricing_args')
16571 
    if self.sourceItemPricing is not None:
16572 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
16573 
      self.sourceItemPricing.write(oprot)
16574 
      oprot.writeFieldEnd()
16575 
    oprot.writeFieldStop()
16576 
    oprot.writeStructEnd()
16577 
 
16578 
  def validate(self):
16579 
    return
16580 
 
16581 
 
16582 
  def __repr__(self):
16583 
    L = ['%s=%r' % (key, value)
16584 
      for key, value in self.__dict__.iteritems()]
16585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16586 
 
16587 
  def __eq__(self, other):
16588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16589 
 
16590 
  def __ne__(self, other):
16591 
    return not (self == other)
16592 
 
16593 
class addSourceItemPricing_result:
16594 
  """
16595 
  Attributes:
16596 
   - cex
16597 
  """
16598 
 
16599 
  thrift_spec = (
16600 
    None, # 0
16601 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16602 
  )
16603 
 
16604 
  def __init__(self, cex=None,):
16605 
    self.cex = cex
16606 
 
16607 
  def read(self, iprot):
16608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16610 
      return
16611 
    iprot.readStructBegin()
16612 
    while True:
16613 
      (fname, ftype, fid) = iprot.readFieldBegin()
16614 
      if ftype == TType.STOP:
16615 
        break
16616 
      if fid == 1:
16617 
        if ftype == TType.STRUCT:
16618 
          self.cex = CatalogServiceException()
16619 
          self.cex.read(iprot)
16620 
        else:
16621 
          iprot.skip(ftype)
16622 
      else:
16623 
        iprot.skip(ftype)
16624 
      iprot.readFieldEnd()
16625 
    iprot.readStructEnd()
16626 
 
16627 
  def write(self, oprot):
16628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16630 
      return
16631 
    oprot.writeStructBegin('addSourceItemPricing_result')
16632 
    if self.cex is not None:
16633 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16634 
      self.cex.write(oprot)
16635 
      oprot.writeFieldEnd()
16636 
    oprot.writeFieldStop()
16637 
    oprot.writeStructEnd()
16638 
 
16639 
  def validate(self):
16640 
    return
16641 
 
16642 
 
16643 
  def __repr__(self):
16644 
    L = ['%s=%r' % (key, value)
16645 
      for key, value in self.__dict__.iteritems()]
16646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16647 
 
16648 
  def __eq__(self, other):
16649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16650 
 
16651 
  def __ne__(self, other):
16652 
    return not (self == other)
16653 
 
16654 
class getAllSourcePricing_args:
16655 
  """
16656 
  Attributes:
16657 
   - itemId
16658 
  """
16659 
 
16660 
  thrift_spec = (
16661 
    None, # 0
16662 
    (1, TType.I64, 'itemId', None, None, ), # 1
16663 
  )
16664 
 
16665 
  def __init__(self, itemId=None,):
16666 
    self.itemId = itemId
16667 
 
16668 
  def read(self, iprot):
16669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16671 
      return
16672 
    iprot.readStructBegin()
16673 
    while True:
16674 
      (fname, ftype, fid) = iprot.readFieldBegin()
16675 
      if ftype == TType.STOP:
16676 
        break
16677 
      if fid == 1:
16678 
        if ftype == TType.I64:
16679 
          self.itemId = iprot.readI64();
16680 
        else:
16681 
          iprot.skip(ftype)
16682 
      else:
16683 
        iprot.skip(ftype)
16684 
      iprot.readFieldEnd()
16685 
    iprot.readStructEnd()
16686 
 
16687 
  def write(self, oprot):
16688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16690 
      return
16691 
    oprot.writeStructBegin('getAllSourcePricing_args')
16692 
    if self.itemId is not None:
16693 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16694 
      oprot.writeI64(self.itemId)
16695 
      oprot.writeFieldEnd()
16696 
    oprot.writeFieldStop()
16697 
    oprot.writeStructEnd()
16698 
 
16699 
  def validate(self):
16700 
    return
16701 
 
16702 
 
16703 
  def __repr__(self):
16704 
    L = ['%s=%r' % (key, value)
16705 
      for key, value in self.__dict__.iteritems()]
16706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16707 
 
16708 
  def __eq__(self, other):
16709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16710 
 
16711 
  def __ne__(self, other):
16712 
    return not (self == other)
16713 
 
16714 
class getAllSourcePricing_result:
16715 
  """
16716 
  Attributes:
16717 
   - success
16718 
   - cex
16719 
  """
16720 
 
16721 
  thrift_spec = (
16722 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
16723 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16724 
  )
16725 
 
16726 
  def __init__(self, success=None, cex=None,):
16727 
    self.success = success
16728 
    self.cex = cex
16729 
 
16730 
  def read(self, iprot):
16731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16733 
      return
16734 
    iprot.readStructBegin()
16735 
    while True:
16736 
      (fname, ftype, fid) = iprot.readFieldBegin()
16737 
      if ftype == TType.STOP:
16738 
        break
16739 
      if fid == 0:
16740 
        if ftype == TType.LIST:
16741 
          self.success = []
9155 kshitij.so 16742 
          (_etype321, _size318) = iprot.readListBegin()
16743 
          for _i322 in xrange(_size318):
16744 
            _elem323 = SourceItemPricing()
16745 
            _elem323.read(iprot)
16746 
            self.success.append(_elem323)
5944 mandeep.dh 16747 
          iprot.readListEnd()
16748 
        else:
16749 
          iprot.skip(ftype)
16750 
      elif fid == 1:
16751 
        if ftype == TType.STRUCT:
16752 
          self.cex = CatalogServiceException()
16753 
          self.cex.read(iprot)
16754 
        else:
16755 
          iprot.skip(ftype)
16756 
      else:
16757 
        iprot.skip(ftype)
16758 
      iprot.readFieldEnd()
16759 
    iprot.readStructEnd()
16760 
 
16761 
  def write(self, oprot):
16762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16764 
      return
16765 
    oprot.writeStructBegin('getAllSourcePricing_result')
16766 
    if self.success is not None:
16767 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16768 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16769 
      for iter324 in self.success:
16770 
        iter324.write(oprot)
5944 mandeep.dh 16771 
      oprot.writeListEnd()
16772 
      oprot.writeFieldEnd()
16773 
    if self.cex is not None:
16774 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16775 
      self.cex.write(oprot)
16776 
      oprot.writeFieldEnd()
16777 
    oprot.writeFieldStop()
16778 
    oprot.writeStructEnd()
16779 
 
16780 
  def validate(self):
16781 
    return
16782 
 
16783 
 
16784 
  def __repr__(self):
16785 
    L = ['%s=%r' % (key, value)
16786 
      for key, value in self.__dict__.iteritems()]
16787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16788 
 
16789 
  def __eq__(self, other):
16790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16791 
 
16792 
  def __ne__(self, other):
16793 
    return not (self == other)
16794 
 
16795 
class getItemForSource_args:
16796 
  """
16797 
  Attributes:
16798 
   - item_id
16799 
   - sourceId
16800 
  """
16801 
 
16802 
  thrift_spec = (
16803 
    None, # 0
16804 
    (1, TType.I64, 'item_id', None, None, ), # 1
16805 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16806 
  )
16807 
 
16808 
  def __init__(self, item_id=None, sourceId=None,):
16809 
    self.item_id = item_id
16810 
    self.sourceId = sourceId
16811 
 
16812 
  def read(self, iprot):
16813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16815 
      return
16816 
    iprot.readStructBegin()
16817 
    while True:
16818 
      (fname, ftype, fid) = iprot.readFieldBegin()
16819 
      if ftype == TType.STOP:
16820 
        break
16821 
      if fid == 1:
16822 
        if ftype == TType.I64:
16823 
          self.item_id = iprot.readI64();
16824 
        else:
16825 
          iprot.skip(ftype)
16826 
      elif fid == 2:
16827 
        if ftype == TType.I64:
16828 
          self.sourceId = iprot.readI64();
16829 
        else:
16830 
          iprot.skip(ftype)
16831 
      else:
16832 
        iprot.skip(ftype)
16833 
      iprot.readFieldEnd()
16834 
    iprot.readStructEnd()
16835 
 
16836 
  def write(self, oprot):
16837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16839 
      return
16840 
    oprot.writeStructBegin('getItemForSource_args')
16841 
    if self.item_id is not None:
16842 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
16843 
      oprot.writeI64(self.item_id)
16844 
      oprot.writeFieldEnd()
16845 
    if self.sourceId is not None:
16846 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16847 
      oprot.writeI64(self.sourceId)
16848 
      oprot.writeFieldEnd()
16849 
    oprot.writeFieldStop()
16850 
    oprot.writeStructEnd()
16851 
 
16852 
  def validate(self):
16853 
    return
16854 
 
16855 
 
16856 
  def __repr__(self):
16857 
    L = ['%s=%r' % (key, value)
16858 
      for key, value in self.__dict__.iteritems()]
16859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16860 
 
16861 
  def __eq__(self, other):
16862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16863 
 
16864 
  def __ne__(self, other):
16865 
    return not (self == other)
16866 
 
16867 
class getItemForSource_result:
16868 
  """
16869 
  Attributes:
16870 
   - success
16871 
   - cex
16872 
  """
16873 
 
16874 
  thrift_spec = (
16875 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
16876 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16877 
  )
16878 
 
16879 
  def __init__(self, success=None, cex=None,):
16880 
    self.success = success
16881 
    self.cex = cex
16882 
 
16883 
  def read(self, iprot):
16884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16886 
      return
16887 
    iprot.readStructBegin()
16888 
    while True:
16889 
      (fname, ftype, fid) = iprot.readFieldBegin()
16890 
      if ftype == TType.STOP:
16891 
        break
16892 
      if fid == 0:
16893 
        if ftype == TType.STRUCT:
16894 
          self.success = Item()
16895 
          self.success.read(iprot)
16896 
        else:
16897 
          iprot.skip(ftype)
16898 
      elif fid == 1:
16899 
        if ftype == TType.STRUCT:
16900 
          self.cex = CatalogServiceException()
16901 
          self.cex.read(iprot)
16902 
        else:
16903 
          iprot.skip(ftype)
16904 
      else:
16905 
        iprot.skip(ftype)
16906 
      iprot.readFieldEnd()
16907 
    iprot.readStructEnd()
16908 
 
16909 
  def write(self, oprot):
16910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16912 
      return
16913 
    oprot.writeStructBegin('getItemForSource_result')
16914 
    if self.success is not None:
16915 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16916 
      self.success.write(oprot)
16917 
      oprot.writeFieldEnd()
16918 
    if self.cex is not None:
16919 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16920 
      self.cex.write(oprot)
16921 
      oprot.writeFieldEnd()
16922 
    oprot.writeFieldStop()
16923 
    oprot.writeStructEnd()
16924 
 
16925 
  def validate(self):
16926 
    return
16927 
 
16928 
 
16929 
  def __repr__(self):
16930 
    L = ['%s=%r' % (key, value)
16931 
      for key, value in self.__dict__.iteritems()]
16932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16933 
 
16934 
  def __eq__(self, other):
16935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16936 
 
16937 
  def __ne__(self, other):
16938 
    return not (self == other)
16939 
 
16940 
class searchItemsInRange_args:
16941 
  """
16942 
  Attributes:
16943 
   - searchTerms
16944 
   - offset
16945 
   - limit
16946 
  """
16947 
 
16948 
  thrift_spec = (
16949 
    None, # 0
16950 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16951 
    (2, TType.I64, 'offset', None, None, ), # 2
16952 
    (3, TType.I64, 'limit', None, None, ), # 3
16953 
  )
16954 
 
16955 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
16956 
    self.searchTerms = searchTerms
16957 
    self.offset = offset
16958 
    self.limit = limit
16959 
 
16960 
  def read(self, iprot):
16961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16963 
      return
16964 
    iprot.readStructBegin()
16965 
    while True:
16966 
      (fname, ftype, fid) = iprot.readFieldBegin()
16967 
      if ftype == TType.STOP:
16968 
        break
16969 
      if fid == 1:
16970 
        if ftype == TType.LIST:
16971 
          self.searchTerms = []
9155 kshitij.so 16972 
          (_etype328, _size325) = iprot.readListBegin()
16973 
          for _i329 in xrange(_size325):
16974 
            _elem330 = iprot.readString();
16975 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 16976 
          iprot.readListEnd()
16977 
        else:
16978 
          iprot.skip(ftype)
16979 
      elif fid == 2:
16980 
        if ftype == TType.I64:
16981 
          self.offset = iprot.readI64();
16982 
        else:
16983 
          iprot.skip(ftype)
16984 
      elif fid == 3:
16985 
        if ftype == TType.I64:
16986 
          self.limit = iprot.readI64();
16987 
        else:
16988 
          iprot.skip(ftype)
16989 
      else:
16990 
        iprot.skip(ftype)
16991 
      iprot.readFieldEnd()
16992 
    iprot.readStructEnd()
16993 
 
16994 
  def write(self, oprot):
16995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16997 
      return
16998 
    oprot.writeStructBegin('searchItemsInRange_args')
16999 
    if self.searchTerms is not None:
17000 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17001 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17002 
      for iter331 in self.searchTerms:
17003 
        oprot.writeString(iter331)
5944 mandeep.dh 17004 
      oprot.writeListEnd()
17005 
      oprot.writeFieldEnd()
17006 
    if self.offset is not None:
17007 
      oprot.writeFieldBegin('offset', TType.I64, 2)
17008 
      oprot.writeI64(self.offset)
17009 
      oprot.writeFieldEnd()
17010 
    if self.limit is not None:
17011 
      oprot.writeFieldBegin('limit', TType.I64, 3)
17012 
      oprot.writeI64(self.limit)
17013 
      oprot.writeFieldEnd()
17014 
    oprot.writeFieldStop()
17015 
    oprot.writeStructEnd()
17016 
 
17017 
  def validate(self):
17018 
    return
17019 
 
17020 
 
17021 
  def __repr__(self):
17022 
    L = ['%s=%r' % (key, value)
17023 
      for key, value in self.__dict__.iteritems()]
17024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17025 
 
17026 
  def __eq__(self, other):
17027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17028 
 
17029 
  def __ne__(self, other):
17030 
    return not (self == other)
17031 
 
17032 
class searchItemsInRange_result:
17033 
  """
17034 
  Attributes:
17035 
   - success
17036 
  """
17037 
 
17038 
  thrift_spec = (
17039 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17040 
  )
17041 
 
17042 
  def __init__(self, success=None,):
17043 
    self.success = success
17044 
 
17045 
  def read(self, iprot):
17046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17048 
      return
17049 
    iprot.readStructBegin()
17050 
    while True:
17051 
      (fname, ftype, fid) = iprot.readFieldBegin()
17052 
      if ftype == TType.STOP:
17053 
        break
17054 
      if fid == 0:
17055 
        if ftype == TType.LIST:
17056 
          self.success = []
9155 kshitij.so 17057 
          (_etype335, _size332) = iprot.readListBegin()
17058 
          for _i336 in xrange(_size332):
17059 
            _elem337 = Item()
17060 
            _elem337.read(iprot)
17061 
            self.success.append(_elem337)
5944 mandeep.dh 17062 
          iprot.readListEnd()
17063 
        else:
17064 
          iprot.skip(ftype)
17065 
      else:
17066 
        iprot.skip(ftype)
17067 
      iprot.readFieldEnd()
17068 
    iprot.readStructEnd()
17069 
 
17070 
  def write(self, oprot):
17071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17073 
      return
17074 
    oprot.writeStructBegin('searchItemsInRange_result')
17075 
    if self.success is not None:
17076 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17077 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17078 
      for iter338 in self.success:
17079 
        iter338.write(oprot)
5944 mandeep.dh 17080 
      oprot.writeListEnd()
17081 
      oprot.writeFieldEnd()
17082 
    oprot.writeFieldStop()
17083 
    oprot.writeStructEnd()
17084 
 
17085 
  def validate(self):
17086 
    return
17087 
 
17088 
 
17089 
  def __repr__(self):
17090 
    L = ['%s=%r' % (key, value)
17091 
      for key, value in self.__dict__.iteritems()]
17092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17093 
 
17094 
  def __eq__(self, other):
17095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17096 
 
17097 
  def __ne__(self, other):
17098 
    return not (self == other)
17099 
 
17100 
class getSearchResultCount_args:
17101 
  """
17102 
  Attributes:
17103 
   - searchTerms
17104 
  """
17105 
 
17106 
  thrift_spec = (
17107 
    None, # 0
17108 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17109 
  )
17110 
 
17111 
  def __init__(self, searchTerms=None,):
17112 
    self.searchTerms = searchTerms
17113 
 
17114 
  def read(self, iprot):
17115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17117 
      return
17118 
    iprot.readStructBegin()
17119 
    while True:
17120 
      (fname, ftype, fid) = iprot.readFieldBegin()
17121 
      if ftype == TType.STOP:
17122 
        break
17123 
      if fid == 1:
17124 
        if ftype == TType.LIST:
17125 
          self.searchTerms = []
9155 kshitij.so 17126 
          (_etype342, _size339) = iprot.readListBegin()
17127 
          for _i343 in xrange(_size339):
17128 
            _elem344 = iprot.readString();
17129 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 17130 
          iprot.readListEnd()
17131 
        else:
17132 
          iprot.skip(ftype)
17133 
      else:
17134 
        iprot.skip(ftype)
17135 
      iprot.readFieldEnd()
17136 
    iprot.readStructEnd()
17137 
 
17138 
  def write(self, oprot):
17139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17141 
      return
17142 
    oprot.writeStructBegin('getSearchResultCount_args')
17143 
    if self.searchTerms is not None:
17144 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17145 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17146 
      for iter345 in self.searchTerms:
17147 
        oprot.writeString(iter345)
5944 mandeep.dh 17148 
      oprot.writeListEnd()
17149 
      oprot.writeFieldEnd()
17150 
    oprot.writeFieldStop()
17151 
    oprot.writeStructEnd()
17152 
 
17153 
  def validate(self):
17154 
    return
17155 
 
17156 
 
17157 
  def __repr__(self):
17158 
    L = ['%s=%r' % (key, value)
17159 
      for key, value in self.__dict__.iteritems()]
17160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17161 
 
17162 
  def __eq__(self, other):
17163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17164 
 
17165 
  def __ne__(self, other):
17166 
    return not (self == other)
17167 
 
17168 
class getSearchResultCount_result:
17169 
  """
17170 
  Attributes:
17171 
   - success
17172 
  """
17173 
 
17174 
  thrift_spec = (
17175 
    (0, TType.I32, 'success', None, None, ), # 0
17176 
  )
17177 
 
17178 
  def __init__(self, success=None,):
17179 
    self.success = success
17180 
 
17181 
  def read(self, iprot):
17182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17184 
      return
17185 
    iprot.readStructBegin()
17186 
    while True:
17187 
      (fname, ftype, fid) = iprot.readFieldBegin()
17188 
      if ftype == TType.STOP:
17189 
        break
17190 
      if fid == 0:
17191 
        if ftype == TType.I32:
17192 
          self.success = iprot.readI32();
17193 
        else:
17194 
          iprot.skip(ftype)
17195 
      else:
17196 
        iprot.skip(ftype)
17197 
      iprot.readFieldEnd()
17198 
    iprot.readStructEnd()
17199 
 
17200 
  def write(self, oprot):
17201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17203 
      return
17204 
    oprot.writeStructBegin('getSearchResultCount_result')
17205 
    if self.success is not None:
17206 
      oprot.writeFieldBegin('success', TType.I32, 0)
17207 
      oprot.writeI32(self.success)
17208 
      oprot.writeFieldEnd()
17209 
    oprot.writeFieldStop()
17210 
    oprot.writeStructEnd()
17211 
 
17212 
  def validate(self):
17213 
    return
17214 
 
17215 
 
17216 
  def __repr__(self):
17217 
    L = ['%s=%r' % (key, value)
17218 
      for key, value in self.__dict__.iteritems()]
17219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17220 
 
17221 
  def __eq__(self, other):
17222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17223 
 
17224 
  def __ne__(self, other):
17225 
    return not (self == other)
17226 
 
17227 
class getProductNotifications_args:
17228 
  """
17229 
  Attributes:
17230 
   - startDateTime
17231 
  """
17232 
 
17233 
  thrift_spec = (
17234 
    None, # 0
17235 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
17236 
  )
17237 
 
17238 
  def __init__(self, startDateTime=None,):
17239 
    self.startDateTime = startDateTime
17240 
 
17241 
  def read(self, iprot):
17242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17244 
      return
17245 
    iprot.readStructBegin()
17246 
    while True:
17247 
      (fname, ftype, fid) = iprot.readFieldBegin()
17248 
      if ftype == TType.STOP:
17249 
        break
17250 
      if fid == 1:
17251 
        if ftype == TType.I64:
17252 
          self.startDateTime = iprot.readI64();
17253 
        else:
17254 
          iprot.skip(ftype)
17255 
      else:
17256 
        iprot.skip(ftype)
17257 
      iprot.readFieldEnd()
17258 
    iprot.readStructEnd()
17259 
 
17260 
  def write(self, oprot):
17261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17263 
      return
17264 
    oprot.writeStructBegin('getProductNotifications_args')
17265 
    if self.startDateTime is not None:
17266 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17267 
      oprot.writeI64(self.startDateTime)
17268 
      oprot.writeFieldEnd()
17269 
    oprot.writeFieldStop()
17270 
    oprot.writeStructEnd()
17271 
 
17272 
  def validate(self):
17273 
    return
17274 
 
17275 
 
17276 
  def __repr__(self):
17277 
    L = ['%s=%r' % (key, value)
17278 
      for key, value in self.__dict__.iteritems()]
17279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17280 
 
17281 
  def __eq__(self, other):
17282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17283 
 
17284 
  def __ne__(self, other):
17285 
    return not (self == other)
17286 
 
17287 
class getProductNotifications_result:
17288 
  """
17289 
  Attributes:
17290 
   - success
17291 
  """
17292 
 
17293 
  thrift_spec = (
17294 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
17295 
  )
17296 
 
17297 
  def __init__(self, success=None,):
17298 
    self.success = success
17299 
 
17300 
  def read(self, iprot):
17301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17303 
      return
17304 
    iprot.readStructBegin()
17305 
    while True:
17306 
      (fname, ftype, fid) = iprot.readFieldBegin()
17307 
      if ftype == TType.STOP:
17308 
        break
17309 
      if fid == 0:
17310 
        if ftype == TType.LIST:
17311 
          self.success = []
9155 kshitij.so 17312 
          (_etype349, _size346) = iprot.readListBegin()
17313 
          for _i350 in xrange(_size346):
17314 
            _elem351 = ProductNotificationRequest()
17315 
            _elem351.read(iprot)
17316 
            self.success.append(_elem351)
5944 mandeep.dh 17317 
          iprot.readListEnd()
17318 
        else:
17319 
          iprot.skip(ftype)
17320 
      else:
17321 
        iprot.skip(ftype)
17322 
      iprot.readFieldEnd()
17323 
    iprot.readStructEnd()
17324 
 
17325 
  def write(self, oprot):
17326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17328 
      return
17329 
    oprot.writeStructBegin('getProductNotifications_result')
17330 
    if self.success is not None:
17331 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17332 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17333 
      for iter352 in self.success:
17334 
        iter352.write(oprot)
5944 mandeep.dh 17335 
      oprot.writeListEnd()
17336 
      oprot.writeFieldEnd()
17337 
    oprot.writeFieldStop()
17338 
    oprot.writeStructEnd()
17339 
 
17340 
  def validate(self):
17341 
    return
17342 
 
17343 
 
17344 
  def __repr__(self):
17345 
    L = ['%s=%r' % (key, value)
17346 
      for key, value in self.__dict__.iteritems()]
17347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17348 
 
17349 
  def __eq__(self, other):
17350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17351 
 
17352 
  def __ne__(self, other):
17353 
    return not (self == other)
17354 
 
17355 
class getProductNotificationRequestCount_args:
17356 
  """
17357 
  Attributes:
17358 
   - startDateTime
7897 amar.kumar 17359 
   - categoryId
5944 mandeep.dh 17360 
  """
17361 
 
17362 
  thrift_spec = (
17363 
    None, # 0
17364 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 17365 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 17366 
  )
17367 
 
7897 amar.kumar 17368 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 17369 
    self.startDateTime = startDateTime
7897 amar.kumar 17370 
    self.categoryId = categoryId
5944 mandeep.dh 17371 
 
17372 
  def read(self, iprot):
17373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17375 
      return
17376 
    iprot.readStructBegin()
17377 
    while True:
17378 
      (fname, ftype, fid) = iprot.readFieldBegin()
17379 
      if ftype == TType.STOP:
17380 
        break
17381 
      if fid == 1:
17382 
        if ftype == TType.I64:
17383 
          self.startDateTime = iprot.readI64();
17384 
        else:
17385 
          iprot.skip(ftype)
7897 amar.kumar 17386 
      elif fid == 2:
17387 
        if ftype == TType.I64:
17388 
          self.categoryId = iprot.readI64();
17389 
        else:
17390 
          iprot.skip(ftype)
5944 mandeep.dh 17391 
      else:
17392 
        iprot.skip(ftype)
17393 
      iprot.readFieldEnd()
17394 
    iprot.readStructEnd()
17395 
 
17396 
  def write(self, oprot):
17397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17399 
      return
17400 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
17401 
    if self.startDateTime is not None:
17402 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17403 
      oprot.writeI64(self.startDateTime)
17404 
      oprot.writeFieldEnd()
7897 amar.kumar 17405 
    if self.categoryId is not None:
17406 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
17407 
      oprot.writeI64(self.categoryId)
17408 
      oprot.writeFieldEnd()
5944 mandeep.dh 17409 
    oprot.writeFieldStop()
17410 
    oprot.writeStructEnd()
17411 
 
17412 
  def validate(self):
17413 
    return
17414 
 
17415 
 
17416 
  def __repr__(self):
17417 
    L = ['%s=%r' % (key, value)
17418 
      for key, value in self.__dict__.iteritems()]
17419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17420 
 
17421 
  def __eq__(self, other):
17422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17423 
 
17424 
  def __ne__(self, other):
17425 
    return not (self == other)
17426 
 
17427 
class getProductNotificationRequestCount_result:
17428 
  """
17429 
  Attributes:
17430 
   - success
17431 
  """
17432 
 
17433 
  thrift_spec = (
17434 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
17435 
  )
17436 
 
17437 
  def __init__(self, success=None,):
17438 
    self.success = success
17439 
 
17440 
  def read(self, iprot):
17441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17443 
      return
17444 
    iprot.readStructBegin()
17445 
    while True:
17446 
      (fname, ftype, fid) = iprot.readFieldBegin()
17447 
      if ftype == TType.STOP:
17448 
        break
17449 
      if fid == 0:
17450 
        if ftype == TType.LIST:
17451 
          self.success = []
9155 kshitij.so 17452 
          (_etype356, _size353) = iprot.readListBegin()
17453 
          for _i357 in xrange(_size353):
17454 
            _elem358 = ProductNotificationRequestCount()
17455 
            _elem358.read(iprot)
17456 
            self.success.append(_elem358)
5944 mandeep.dh 17457 
          iprot.readListEnd()
17458 
        else:
17459 
          iprot.skip(ftype)
17460 
      else:
17461 
        iprot.skip(ftype)
17462 
      iprot.readFieldEnd()
17463 
    iprot.readStructEnd()
17464 
 
17465 
  def write(self, oprot):
17466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17468 
      return
17469 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
17470 
    if self.success is not None:
17471 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17472 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17473 
      for iter359 in self.success:
17474 
        iter359.write(oprot)
5944 mandeep.dh 17475 
      oprot.writeListEnd()
17476 
      oprot.writeFieldEnd()
17477 
    oprot.writeFieldStop()
17478 
    oprot.writeStructEnd()
17479 
 
17480 
  def validate(self):
17481 
    return
17482 
 
17483 
 
17484 
  def __repr__(self):
17485 
    L = ['%s=%r' % (key, value)
17486 
      for key, value in self.__dict__.iteritems()]
17487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17488 
 
17489 
  def __eq__(self, other):
17490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17491 
 
17492 
  def __ne__(self, other):
17493 
    return not (self == other)
17494 
 
17495 
class addAuthorizationLog_args:
17496 
  """
17497 
  Attributes:
17498 
   - itemId
17499 
   - username
17500 
   - reason
17501 
  """
17502 
 
17503 
  thrift_spec = (
17504 
    None, # 0
17505 
    (1, TType.I64, 'itemId', None, None, ), # 1
17506 
    (2, TType.STRING, 'username', None, None, ), # 2
17507 
    (3, TType.STRING, 'reason', None, None, ), # 3
17508 
  )
17509 
 
17510 
  def __init__(self, itemId=None, username=None, reason=None,):
17511 
    self.itemId = itemId
17512 
    self.username = username
17513 
    self.reason = reason
17514 
 
17515 
  def read(self, iprot):
17516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17518 
      return
17519 
    iprot.readStructBegin()
17520 
    while True:
17521 
      (fname, ftype, fid) = iprot.readFieldBegin()
17522 
      if ftype == TType.STOP:
17523 
        break
17524 
      if fid == 1:
17525 
        if ftype == TType.I64:
17526 
          self.itemId = iprot.readI64();
17527 
        else:
17528 
          iprot.skip(ftype)
17529 
      elif fid == 2:
17530 
        if ftype == TType.STRING:
17531 
          self.username = iprot.readString();
17532 
        else:
17533 
          iprot.skip(ftype)
17534 
      elif fid == 3:
17535 
        if ftype == TType.STRING:
17536 
          self.reason = iprot.readString();
17537 
        else:
17538 
          iprot.skip(ftype)
17539 
      else:
17540 
        iprot.skip(ftype)
17541 
      iprot.readFieldEnd()
17542 
    iprot.readStructEnd()
17543 
 
17544 
  def write(self, oprot):
17545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17547 
      return
17548 
    oprot.writeStructBegin('addAuthorizationLog_args')
17549 
    if self.itemId is not None:
17550 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17551 
      oprot.writeI64(self.itemId)
17552 
      oprot.writeFieldEnd()
17553 
    if self.username is not None:
17554 
      oprot.writeFieldBegin('username', TType.STRING, 2)
17555 
      oprot.writeString(self.username)
17556 
      oprot.writeFieldEnd()
17557 
    if self.reason is not None:
17558 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17559 
      oprot.writeString(self.reason)
17560 
      oprot.writeFieldEnd()
17561 
    oprot.writeFieldStop()
17562 
    oprot.writeStructEnd()
17563 
 
17564 
  def validate(self):
17565 
    return
17566 
 
17567 
 
17568 
  def __repr__(self):
17569 
    L = ['%s=%r' % (key, value)
17570 
      for key, value in self.__dict__.iteritems()]
17571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17572 
 
17573 
  def __eq__(self, other):
17574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17575 
 
17576 
  def __ne__(self, other):
17577 
    return not (self == other)
17578 
 
17579 
class addAuthorizationLog_result:
17580 
  """
17581 
  Attributes:
17582 
   - success
17583 
   - cex
17584 
  """
17585 
 
17586 
  thrift_spec = (
17587 
    (0, TType.BOOL, 'success', None, None, ), # 0
17588 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17589 
  )
17590 
 
17591 
  def __init__(self, success=None, cex=None,):
17592 
    self.success = success
17593 
    self.cex = cex
17594 
 
17595 
  def read(self, iprot):
17596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17598 
      return
17599 
    iprot.readStructBegin()
17600 
    while True:
17601 
      (fname, ftype, fid) = iprot.readFieldBegin()
17602 
      if ftype == TType.STOP:
17603 
        break
17604 
      if fid == 0:
17605 
        if ftype == TType.BOOL:
17606 
          self.success = iprot.readBool();
17607 
        else:
17608 
          iprot.skip(ftype)
17609 
      elif fid == 1:
17610 
        if ftype == TType.STRUCT:
17611 
          self.cex = CatalogServiceException()
17612 
          self.cex.read(iprot)
17613 
        else:
17614 
          iprot.skip(ftype)
17615 
      else:
17616 
        iprot.skip(ftype)
17617 
      iprot.readFieldEnd()
17618 
    iprot.readStructEnd()
17619 
 
17620 
  def write(self, oprot):
17621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17623 
      return
17624 
    oprot.writeStructBegin('addAuthorizationLog_result')
17625 
    if self.success is not None:
17626 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17627 
      oprot.writeBool(self.success)
17628 
      oprot.writeFieldEnd()
17629 
    if self.cex is not None:
17630 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17631 
      self.cex.write(oprot)
17632 
      oprot.writeFieldEnd()
17633 
    oprot.writeFieldStop()
17634 
    oprot.writeStructEnd()
17635 
 
17636 
  def validate(self):
17637 
    return
17638 
 
17639 
 
17640 
  def __repr__(self):
17641 
    L = ['%s=%r' % (key, value)
17642 
      for key, value in self.__dict__.iteritems()]
17643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17644 
 
17645 
  def __eq__(self, other):
17646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17647 
 
17648 
  def __ne__(self, other):
17649 
    return not (self == other)
17650 
 
17651 
class addupdateVoucherForItem_args:
17652 
  """
17653 
  Attributes:
17654 
   - catalog_item_id
17655 
   - voucherType
17656 
   - voucherAmount
17657 
  """
17658 
 
17659 
  thrift_spec = (
17660 
    None, # 0
17661 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17662 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17663 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
17664 
  )
17665 
 
17666 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
17667 
    self.catalog_item_id = catalog_item_id
17668 
    self.voucherType = voucherType
17669 
    self.voucherAmount = voucherAmount
17670 
 
17671 
  def read(self, iprot):
17672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17674 
      return
17675 
    iprot.readStructBegin()
17676 
    while True:
17677 
      (fname, ftype, fid) = iprot.readFieldBegin()
17678 
      if ftype == TType.STOP:
17679 
        break
17680 
      if fid == 1:
17681 
        if ftype == TType.I64:
17682 
          self.catalog_item_id = iprot.readI64();
17683 
        else:
17684 
          iprot.skip(ftype)
17685 
      elif fid == 2:
17686 
        if ftype == TType.I64:
17687 
          self.voucherType = iprot.readI64();
17688 
        else:
17689 
          iprot.skip(ftype)
17690 
      elif fid == 3:
17691 
        if ftype == TType.I64:
17692 
          self.voucherAmount = iprot.readI64();
17693 
        else:
17694 
          iprot.skip(ftype)
17695 
      else:
17696 
        iprot.skip(ftype)
17697 
      iprot.readFieldEnd()
17698 
    iprot.readStructEnd()
17699 
 
17700 
  def write(self, oprot):
17701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17703 
      return
17704 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
17705 
    if self.catalog_item_id is not None:
17706 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17707 
      oprot.writeI64(self.catalog_item_id)
17708 
      oprot.writeFieldEnd()
17709 
    if self.voucherType is not None:
17710 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17711 
      oprot.writeI64(self.voucherType)
17712 
      oprot.writeFieldEnd()
17713 
    if self.voucherAmount is not None:
17714 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
17715 
      oprot.writeI64(self.voucherAmount)
17716 
      oprot.writeFieldEnd()
17717 
    oprot.writeFieldStop()
17718 
    oprot.writeStructEnd()
17719 
 
17720 
  def validate(self):
17721 
    return
17722 
 
17723 
 
17724 
  def __repr__(self):
17725 
    L = ['%s=%r' % (key, value)
17726 
      for key, value in self.__dict__.iteritems()]
17727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17728 
 
17729 
  def __eq__(self, other):
17730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17731 
 
17732 
  def __ne__(self, other):
17733 
    return not (self == other)
17734 
 
17735 
class addupdateVoucherForItem_result:
17736 
  """
17737 
  Attributes:
17738 
   - success
17739 
   - cex
17740 
  """
17741 
 
17742 
  thrift_spec = (
17743 
    (0, TType.BOOL, 'success', None, None, ), # 0
17744 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17745 
  )
17746 
 
17747 
  def __init__(self, success=None, cex=None,):
17748 
    self.success = success
17749 
    self.cex = cex
17750 
 
17751 
  def read(self, iprot):
17752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17754 
      return
17755 
    iprot.readStructBegin()
17756 
    while True:
17757 
      (fname, ftype, fid) = iprot.readFieldBegin()
17758 
      if ftype == TType.STOP:
17759 
        break
17760 
      if fid == 0:
17761 
        if ftype == TType.BOOL:
17762 
          self.success = iprot.readBool();
17763 
        else:
17764 
          iprot.skip(ftype)
17765 
      elif fid == 1:
17766 
        if ftype == TType.STRUCT:
17767 
          self.cex = CatalogServiceException()
17768 
          self.cex.read(iprot)
17769 
        else:
17770 
          iprot.skip(ftype)
17771 
      else:
17772 
        iprot.skip(ftype)
17773 
      iprot.readFieldEnd()
17774 
    iprot.readStructEnd()
17775 
 
17776 
  def write(self, oprot):
17777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17779 
      return
17780 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
17781 
    if self.success is not None:
17782 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17783 
      oprot.writeBool(self.success)
17784 
      oprot.writeFieldEnd()
17785 
    if self.cex is not None:
17786 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17787 
      self.cex.write(oprot)
17788 
      oprot.writeFieldEnd()
17789 
    oprot.writeFieldStop()
17790 
    oprot.writeStructEnd()
17791 
 
17792 
  def validate(self):
17793 
    return
17794 
 
17795 
 
17796 
  def __repr__(self):
17797 
    L = ['%s=%r' % (key, value)
17798 
      for key, value in self.__dict__.iteritems()]
17799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17800 
 
17801 
  def __eq__(self, other):
17802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17803 
 
17804 
  def __ne__(self, other):
17805 
    return not (self == other)
17806 
 
17807 
class deleteVoucherForItem_args:
17808 
  """
17809 
  Attributes:
17810 
   - catalog_item_id
17811 
   - voucherType
17812 
  """
17813 
 
17814 
  thrift_spec = (
17815 
    None, # 0
17816 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17817 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17818 
  )
17819 
 
17820 
  def __init__(self, catalog_item_id=None, voucherType=None,):
17821 
    self.catalog_item_id = catalog_item_id
17822 
    self.voucherType = voucherType
17823 
 
17824 
  def read(self, iprot):
17825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17827 
      return
17828 
    iprot.readStructBegin()
17829 
    while True:
17830 
      (fname, ftype, fid) = iprot.readFieldBegin()
17831 
      if ftype == TType.STOP:
17832 
        break
17833 
      if fid == 1:
17834 
        if ftype == TType.I64:
17835 
          self.catalog_item_id = iprot.readI64();
17836 
        else:
17837 
          iprot.skip(ftype)
17838 
      elif fid == 2:
17839 
        if ftype == TType.I64:
17840 
          self.voucherType = iprot.readI64();
17841 
        else:
17842 
          iprot.skip(ftype)
17843 
      else:
17844 
        iprot.skip(ftype)
17845 
      iprot.readFieldEnd()
17846 
    iprot.readStructEnd()
17847 
 
17848 
  def write(self, oprot):
17849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17851 
      return
17852 
    oprot.writeStructBegin('deleteVoucherForItem_args')
17853 
    if self.catalog_item_id is not None:
17854 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17855 
      oprot.writeI64(self.catalog_item_id)
17856 
      oprot.writeFieldEnd()
17857 
    if self.voucherType is not None:
17858 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17859 
      oprot.writeI64(self.voucherType)
17860 
      oprot.writeFieldEnd()
17861 
    oprot.writeFieldStop()
17862 
    oprot.writeStructEnd()
17863 
 
17864 
  def validate(self):
17865 
    return
17866 
 
17867 
 
17868 
  def __repr__(self):
17869 
    L = ['%s=%r' % (key, value)
17870 
      for key, value in self.__dict__.iteritems()]
17871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17872 
 
17873 
  def __eq__(self, other):
17874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17875 
 
17876 
  def __ne__(self, other):
17877 
    return not (self == other)
17878 
 
17879 
class deleteVoucherForItem_result:
17880 
  """
17881 
  Attributes:
17882 
   - success
17883 
   - cex
17884 
  """
17885 
 
17886 
  thrift_spec = (
17887 
    (0, TType.BOOL, 'success', None, None, ), # 0
17888 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17889 
  )
17890 
 
17891 
  def __init__(self, success=None, cex=None,):
17892 
    self.success = success
17893 
    self.cex = cex
17894 
 
17895 
  def read(self, iprot):
17896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17898 
      return
17899 
    iprot.readStructBegin()
17900 
    while True:
17901 
      (fname, ftype, fid) = iprot.readFieldBegin()
17902 
      if ftype == TType.STOP:
17903 
        break
17904 
      if fid == 0:
17905 
        if ftype == TType.BOOL:
17906 
          self.success = iprot.readBool();
17907 
        else:
17908 
          iprot.skip(ftype)
17909 
      elif fid == 1:
17910 
        if ftype == TType.STRUCT:
17911 
          self.cex = CatalogServiceException()
17912 
          self.cex.read(iprot)
17913 
        else:
17914 
          iprot.skip(ftype)
17915 
      else:
17916 
        iprot.skip(ftype)
17917 
      iprot.readFieldEnd()
17918 
    iprot.readStructEnd()
17919 
 
17920 
  def write(self, oprot):
17921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17923 
      return
17924 
    oprot.writeStructBegin('deleteVoucherForItem_result')
17925 
    if self.success is not None:
17926 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17927 
      oprot.writeBool(self.success)
17928 
      oprot.writeFieldEnd()
17929 
    if self.cex is not None:
17930 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17931 
      self.cex.write(oprot)
17932 
      oprot.writeFieldEnd()
17933 
    oprot.writeFieldStop()
17934 
    oprot.writeStructEnd()
17935 
 
17936 
  def validate(self):
17937 
    return
17938 
 
17939 
 
17940 
  def __repr__(self):
17941 
    L = ['%s=%r' % (key, value)
17942 
      for key, value in self.__dict__.iteritems()]
17943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17944 
 
17945 
  def __eq__(self, other):
17946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17947 
 
17948 
  def __ne__(self, other):
17949 
    return not (self == other)
17950 
 
17951 
class getVoucherAmount_args:
17952 
  """
17953 
  Attributes:
17954 
   - itemId
17955 
   - voucherType
17956 
  """
17957 
 
17958 
  thrift_spec = (
17959 
    None, # 0
17960 
    (1, TType.I64, 'itemId', None, None, ), # 1
17961 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17962 
  )
17963 
 
17964 
  def __init__(self, itemId=None, voucherType=None,):
17965 
    self.itemId = itemId
17966 
    self.voucherType = voucherType
17967 
 
17968 
  def read(self, iprot):
17969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17971 
      return
17972 
    iprot.readStructBegin()
17973 
    while True:
17974 
      (fname, ftype, fid) = iprot.readFieldBegin()
17975 
      if ftype == TType.STOP:
17976 
        break
17977 
      if fid == 1:
17978 
        if ftype == TType.I64:
17979 
          self.itemId = iprot.readI64();
17980 
        else:
17981 
          iprot.skip(ftype)
17982 
      elif fid == 2:
17983 
        if ftype == TType.I64:
17984 
          self.voucherType = iprot.readI64();
17985 
        else:
17986 
          iprot.skip(ftype)
17987 
      else:
17988 
        iprot.skip(ftype)
17989 
      iprot.readFieldEnd()
17990 
    iprot.readStructEnd()
17991 
 
17992 
  def write(self, oprot):
17993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17995 
      return
17996 
    oprot.writeStructBegin('getVoucherAmount_args')
17997 
    if self.itemId is not None:
17998 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17999 
      oprot.writeI64(self.itemId)
18000 
      oprot.writeFieldEnd()
18001 
    if self.voucherType is not None:
18002 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18003 
      oprot.writeI64(self.voucherType)
18004 
      oprot.writeFieldEnd()
18005 
    oprot.writeFieldStop()
18006 
    oprot.writeStructEnd()
18007 
 
18008 
  def validate(self):
18009 
    return
18010 
 
18011 
 
18012 
  def __repr__(self):
18013 
    L = ['%s=%r' % (key, value)
18014 
      for key, value in self.__dict__.iteritems()]
18015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18016 
 
18017 
  def __eq__(self, other):
18018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18019 
 
18020 
  def __ne__(self, other):
18021 
    return not (self == other)
18022 
 
18023 
class getVoucherAmount_result:
18024 
  """
18025 
  Attributes:
18026 
   - success
18027 
  """
18028 
 
18029 
  thrift_spec = (
18030 
    (0, TType.I64, 'success', None, None, ), # 0
18031 
  )
18032 
 
18033 
  def __init__(self, success=None,):
18034 
    self.success = success
18035 
 
18036 
  def read(self, iprot):
18037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18039 
      return
18040 
    iprot.readStructBegin()
18041 
    while True:
18042 
      (fname, ftype, fid) = iprot.readFieldBegin()
18043 
      if ftype == TType.STOP:
18044 
        break
18045 
      if fid == 0:
18046 
        if ftype == TType.I64:
18047 
          self.success = iprot.readI64();
18048 
        else:
18049 
          iprot.skip(ftype)
18050 
      else:
18051 
        iprot.skip(ftype)
18052 
      iprot.readFieldEnd()
18053 
    iprot.readStructEnd()
18054 
 
18055 
  def write(self, oprot):
18056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18058 
      return
18059 
    oprot.writeStructBegin('getVoucherAmount_result')
18060 
    if self.success is not None:
18061 
      oprot.writeFieldBegin('success', TType.I64, 0)
18062 
      oprot.writeI64(self.success)
18063 
      oprot.writeFieldEnd()
18064 
    oprot.writeFieldStop()
18065 
    oprot.writeStructEnd()
18066 
 
18067 
  def validate(self):
18068 
    return
18069 
 
18070 
 
18071 
  def __repr__(self):
18072 
    L = ['%s=%r' % (key, value)
18073 
      for key, value in self.__dict__.iteritems()]
18074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18075 
 
18076 
  def __eq__(self, other):
18077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18078 
 
18079 
  def __ne__(self, other):
18080 
    return not (self == other)
18081 
 
18082 
class getAllItemVouchers_args:
18083 
  """
18084 
  Attributes:
18085 
   - itemId
18086 
  """
18087 
 
18088 
  thrift_spec = (
18089 
    None, # 0
18090 
    (1, TType.I64, 'itemId', None, None, ), # 1
18091 
  )
18092 
 
18093 
  def __init__(self, itemId=None,):
18094 
    self.itemId = itemId
18095 
 
18096 
  def read(self, iprot):
18097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18099 
      return
18100 
    iprot.readStructBegin()
18101 
    while True:
18102 
      (fname, ftype, fid) = iprot.readFieldBegin()
18103 
      if ftype == TType.STOP:
18104 
        break
18105 
      if fid == 1:
18106 
        if ftype == TType.I64:
18107 
          self.itemId = iprot.readI64();
18108 
        else:
18109 
          iprot.skip(ftype)
18110 
      else:
18111 
        iprot.skip(ftype)
18112 
      iprot.readFieldEnd()
18113 
    iprot.readStructEnd()
18114 
 
18115 
  def write(self, oprot):
18116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18118 
      return
18119 
    oprot.writeStructBegin('getAllItemVouchers_args')
18120 
    if self.itemId is not None:
18121 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18122 
      oprot.writeI64(self.itemId)
18123 
      oprot.writeFieldEnd()
18124 
    oprot.writeFieldStop()
18125 
    oprot.writeStructEnd()
18126 
 
18127 
  def validate(self):
18128 
    return
18129 
 
18130 
 
18131 
  def __repr__(self):
18132 
    L = ['%s=%r' % (key, value)
18133 
      for key, value in self.__dict__.iteritems()]
18134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18135 
 
18136 
  def __eq__(self, other):
18137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18138 
 
18139 
  def __ne__(self, other):
18140 
    return not (self == other)
18141 
 
18142 
class getAllItemVouchers_result:
18143 
  """
18144 
  Attributes:
18145 
   - success
18146 
  """
18147 
 
18148 
  thrift_spec = (
18149 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
18150 
  )
18151 
 
18152 
  def __init__(self, success=None,):
18153 
    self.success = success
18154 
 
18155 
  def read(self, iprot):
18156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18158 
      return
18159 
    iprot.readStructBegin()
18160 
    while True:
18161 
      (fname, ftype, fid) = iprot.readFieldBegin()
18162 
      if ftype == TType.STOP:
18163 
        break
18164 
      if fid == 0:
18165 
        if ftype == TType.LIST:
18166 
          self.success = []
9155 kshitij.so 18167 
          (_etype363, _size360) = iprot.readListBegin()
18168 
          for _i364 in xrange(_size360):
18169 
            _elem365 = VoucherItemMapping()
18170 
            _elem365.read(iprot)
18171 
            self.success.append(_elem365)
5944 mandeep.dh 18172 
          iprot.readListEnd()
18173 
        else:
18174 
          iprot.skip(ftype)
18175 
      else:
18176 
        iprot.skip(ftype)
18177 
      iprot.readFieldEnd()
18178 
    iprot.readStructEnd()
18179 
 
18180 
  def write(self, oprot):
18181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18183 
      return
18184 
    oprot.writeStructBegin('getAllItemVouchers_result')
18185 
    if self.success is not None:
18186 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18187 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18188 
      for iter366 in self.success:
18189 
        iter366.write(oprot)
5944 mandeep.dh 18190 
      oprot.writeListEnd()
18191 
      oprot.writeFieldEnd()
18192 
    oprot.writeFieldStop()
18193 
    oprot.writeStructEnd()
18194 
 
18195 
  def validate(self):
18196 
    return
18197 
 
18198 
 
18199 
  def __repr__(self):
18200 
    L = ['%s=%r' % (key, value)
18201 
      for key, value in self.__dict__.iteritems()]
18202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18203 
 
18204 
  def __eq__(self, other):
18205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18206 
 
18207 
  def __ne__(self, other):
18208 
    return not (self == other)
18209 
 
18210 
class isValidCatalogItemId_args:
18211 
  """
18212 
  Attributes:
18213 
   - catalog_item_id
18214 
  """
18215 
 
18216 
  thrift_spec = (
18217 
    None, # 0
18218 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18219 
  )
18220 
 
18221 
  def __init__(self, catalog_item_id=None,):
18222 
    self.catalog_item_id = catalog_item_id
18223 
 
18224 
  def read(self, iprot):
18225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18227 
      return
18228 
    iprot.readStructBegin()
18229 
    while True:
18230 
      (fname, ftype, fid) = iprot.readFieldBegin()
18231 
      if ftype == TType.STOP:
18232 
        break
18233 
      if fid == 1:
18234 
        if ftype == TType.I64:
18235 
          self.catalog_item_id = iprot.readI64();
18236 
        else:
18237 
          iprot.skip(ftype)
18238 
      else:
18239 
        iprot.skip(ftype)
18240 
      iprot.readFieldEnd()
18241 
    iprot.readStructEnd()
18242 
 
18243 
  def write(self, oprot):
18244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18246 
      return
18247 
    oprot.writeStructBegin('isValidCatalogItemId_args')
18248 
    if self.catalog_item_id is not None:
18249 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18250 
      oprot.writeI64(self.catalog_item_id)
18251 
      oprot.writeFieldEnd()
18252 
    oprot.writeFieldStop()
18253 
    oprot.writeStructEnd()
18254 
 
18255 
  def validate(self):
18256 
    return
18257 
 
18258 
 
18259 
  def __repr__(self):
18260 
    L = ['%s=%r' % (key, value)
18261 
      for key, value in self.__dict__.iteritems()]
18262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18263 
 
18264 
  def __eq__(self, other):
18265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18266 
 
18267 
  def __ne__(self, other):
18268 
    return not (self == other)
18269 
 
18270 
class isValidCatalogItemId_result:
18271 
  """
18272 
  Attributes:
18273 
   - success
18274 
  """
18275 
 
18276 
  thrift_spec = (
18277 
    (0, TType.BOOL, 'success', None, None, ), # 0
18278 
  )
18279 
 
18280 
  def __init__(self, success=None,):
18281 
    self.success = success
18282 
 
18283 
  def read(self, iprot):
18284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18286 
      return
18287 
    iprot.readStructBegin()
18288 
    while True:
18289 
      (fname, ftype, fid) = iprot.readFieldBegin()
18290 
      if ftype == TType.STOP:
18291 
        break
18292 
      if fid == 0:
18293 
        if ftype == TType.BOOL:
18294 
          self.success = iprot.readBool();
18295 
        else:
18296 
          iprot.skip(ftype)
18297 
      else:
18298 
        iprot.skip(ftype)
18299 
      iprot.readFieldEnd()
18300 
    iprot.readStructEnd()
18301 
 
18302 
  def write(self, oprot):
18303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18305 
      return
18306 
    oprot.writeStructBegin('isValidCatalogItemId_result')
18307 
    if self.success is not None:
18308 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18309 
      oprot.writeBool(self.success)
18310 
      oprot.writeFieldEnd()
18311 
    oprot.writeFieldStop()
18312 
    oprot.writeStructEnd()
18313 
 
18314 
  def validate(self):
18315 
    return
18316 
 
18317 
 
18318 
  def __repr__(self):
18319 
    L = ['%s=%r' % (key, value)
18320 
      for key, value in self.__dict__.iteritems()]
18321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18322 
 
18323 
  def __eq__(self, other):
18324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18325 
 
18326 
  def __ne__(self, other):
18327 
    return not (self == other)
6039 amit.gupta 18328 
 
18329 
class getVatPercentageForItem_args:
18330 
  """
18331 
  Attributes:
18332 
   - itemId
7330 amit.gupta 18333 
   - stateId
6039 amit.gupta 18334 
   - price
18335 
  """
18336 
 
18337 
  thrift_spec = (
18338 
    None, # 0
18339 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 18340 
    (2, TType.I64, 'stateId', None, None, ), # 2
18341 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 18342 
  )
18343 
 
7330 amit.gupta 18344 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 18345 
    self.itemId = itemId
7330 amit.gupta 18346 
    self.stateId = stateId
6039 amit.gupta 18347 
    self.price = price
18348 
 
18349 
  def read(self, iprot):
18350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18352 
      return
18353 
    iprot.readStructBegin()
18354 
    while True:
18355 
      (fname, ftype, fid) = iprot.readFieldBegin()
18356 
      if ftype == TType.STOP:
18357 
        break
18358 
      if fid == 1:
18359 
        if ftype == TType.I64:
18360 
          self.itemId = iprot.readI64();
18361 
        else:
18362 
          iprot.skip(ftype)
18363 
      elif fid == 2:
7330 amit.gupta 18364 
        if ftype == TType.I64:
18365 
          self.stateId = iprot.readI64();
18366 
        else:
18367 
          iprot.skip(ftype)
18368 
      elif fid == 3:
6039 amit.gupta 18369 
        if ftype == TType.DOUBLE:
18370 
          self.price = iprot.readDouble();
18371 
        else:
18372 
          iprot.skip(ftype)
18373 
      else:
18374 
        iprot.skip(ftype)
18375 
      iprot.readFieldEnd()
18376 
    iprot.readStructEnd()
18377 
 
18378 
  def write(self, oprot):
18379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18381 
      return
18382 
    oprot.writeStructBegin('getVatPercentageForItem_args')
18383 
    if self.itemId is not None:
18384 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18385 
      oprot.writeI64(self.itemId)
18386 
      oprot.writeFieldEnd()
7330 amit.gupta 18387 
    if self.stateId is not None:
18388 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
18389 
      oprot.writeI64(self.stateId)
18390 
      oprot.writeFieldEnd()
6039 amit.gupta 18391 
    if self.price is not None:
7330 amit.gupta 18392 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 18393 
      oprot.writeDouble(self.price)
18394 
      oprot.writeFieldEnd()
18395 
    oprot.writeFieldStop()
18396 
    oprot.writeStructEnd()
18397 
 
18398 
  def validate(self):
18399 
    return
18400 
 
18401 
 
18402 
  def __repr__(self):
18403 
    L = ['%s=%r' % (key, value)
18404 
      for key, value in self.__dict__.iteritems()]
18405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18406 
 
18407 
  def __eq__(self, other):
18408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18409 
 
18410 
  def __ne__(self, other):
18411 
    return not (self == other)
18412 
 
18413 
class getVatPercentageForItem_result:
18414 
  """
18415 
  Attributes:
18416 
   - success
7340 amit.gupta 18417 
   - cex
6039 amit.gupta 18418 
  """
18419 
 
18420 
  thrift_spec = (
18421 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 18422 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 18423 
  )
18424 
 
7340 amit.gupta 18425 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 18426 
    self.success = success
7340 amit.gupta 18427 
    self.cex = cex
6039 amit.gupta 18428 
 
18429 
  def read(self, iprot):
18430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18432 
      return
18433 
    iprot.readStructBegin()
18434 
    while True:
18435 
      (fname, ftype, fid) = iprot.readFieldBegin()
18436 
      if ftype == TType.STOP:
18437 
        break
18438 
      if fid == 0:
18439 
        if ftype == TType.DOUBLE:
18440 
          self.success = iprot.readDouble();
18441 
        else:
18442 
          iprot.skip(ftype)
7340 amit.gupta 18443 
      elif fid == 1:
18444 
        if ftype == TType.STRUCT:
18445 
          self.cex = CatalogServiceException()
18446 
          self.cex.read(iprot)
18447 
        else:
18448 
          iprot.skip(ftype)
6039 amit.gupta 18449 
      else:
18450 
        iprot.skip(ftype)
18451 
      iprot.readFieldEnd()
18452 
    iprot.readStructEnd()
18453 
 
18454 
  def write(self, oprot):
18455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18457 
      return
18458 
    oprot.writeStructBegin('getVatPercentageForItem_result')
18459 
    if self.success is not None:
18460 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
18461 
      oprot.writeDouble(self.success)
18462 
      oprot.writeFieldEnd()
7340 amit.gupta 18463 
    if self.cex is not None:
18464 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18465 
      self.cex.write(oprot)
18466 
      oprot.writeFieldEnd()
6039 amit.gupta 18467 
    oprot.writeFieldStop()
18468 
    oprot.writeStructEnd()
18469 
 
18470 
  def validate(self):
18471 
    return
18472 
 
18473 
 
18474 
  def __repr__(self):
18475 
    L = ['%s=%r' % (key, value)
18476 
      for key, value in self.__dict__.iteritems()]
18477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18478 
 
18479 
  def __eq__(self, other):
18480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18481 
 
18482 
  def __ne__(self, other):
18483 
    return not (self == other)
18484 
 
18485 
class getVatAmountForItem_args:
18486 
  """
18487 
  Attributes:
18488 
   - itemId
18489 
   - price
18490 
  """
18491 
 
18492 
  thrift_spec = (
18493 
    None, # 0
18494 
    (1, TType.I64, 'itemId', None, None, ), # 1
18495 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18496 
  )
18497 
 
18498 
  def __init__(self, itemId=None, price=None,):
18499 
    self.itemId = itemId
18500 
    self.price = price
18501 
 
18502 
  def read(self, iprot):
18503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18505 
      return
18506 
    iprot.readStructBegin()
18507 
    while True:
18508 
      (fname, ftype, fid) = iprot.readFieldBegin()
18509 
      if ftype == TType.STOP:
18510 
        break
18511 
      if fid == 1:
18512 
        if ftype == TType.I64:
18513 
          self.itemId = iprot.readI64();
18514 
        else:
18515 
          iprot.skip(ftype)
18516 
      elif fid == 2:
18517 
        if ftype == TType.DOUBLE:
18518 
          self.price = iprot.readDouble();
18519 
        else:
18520 
          iprot.skip(ftype)
18521 
      else:
18522 
        iprot.skip(ftype)
18523 
      iprot.readFieldEnd()
18524 
    iprot.readStructEnd()
18525 
 
18526 
  def write(self, oprot):
18527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18529 
      return
18530 
    oprot.writeStructBegin('getVatAmountForItem_args')
18531 
    if self.itemId is not None:
18532 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18533 
      oprot.writeI64(self.itemId)
18534 
      oprot.writeFieldEnd()
18535 
    if self.price is not None:
18536 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18537 
      oprot.writeDouble(self.price)
18538 
      oprot.writeFieldEnd()
18539 
    oprot.writeFieldStop()
18540 
    oprot.writeStructEnd()
18541 
 
18542 
  def validate(self):
18543 
    return
18544 
 
18545 
 
18546 
  def __repr__(self):
18547 
    L = ['%s=%r' % (key, value)
18548 
      for key, value in self.__dict__.iteritems()]
18549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18550 
 
18551 
  def __eq__(self, other):
18552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18553 
 
18554 
  def __ne__(self, other):
18555 
    return not (self == other)
18556 
 
18557 
class getVatAmountForItem_result:
18558 
  """
18559 
  Attributes:
18560 
   - success
18561 
  """
18562 
 
18563 
  thrift_spec = (
18564 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
18565 
  )
18566 
 
18567 
  def __init__(self, success=None,):
18568 
    self.success = success
18569 
 
18570 
  def read(self, iprot):
18571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18573 
      return
18574 
    iprot.readStructBegin()
18575 
    while True:
18576 
      (fname, ftype, fid) = iprot.readFieldBegin()
18577 
      if ftype == TType.STOP:
18578 
        break
18579 
      if fid == 0:
18580 
        if ftype == TType.DOUBLE:
18581 
          self.success = iprot.readDouble();
18582 
        else:
18583 
          iprot.skip(ftype)
18584 
      else:
18585 
        iprot.skip(ftype)
18586 
      iprot.readFieldEnd()
18587 
    iprot.readStructEnd()
18588 
 
18589 
  def write(self, oprot):
18590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18592 
      return
18593 
    oprot.writeStructBegin('getVatAmountForItem_result')
18594 
    if self.success is not None:
18595 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
18596 
      oprot.writeDouble(self.success)
18597 
      oprot.writeFieldEnd()
18598 
    oprot.writeFieldStop()
18599 
    oprot.writeStructEnd()
18600 
 
18601 
  def validate(self):
18602 
    return
18603 
 
18604 
 
18605 
  def __repr__(self):
18606 
    L = ['%s=%r' % (key, value)
18607 
      for key, value in self.__dict__.iteritems()]
18608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18609 
 
18610 
  def __eq__(self, other):
18611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18612 
 
18613 
  def __ne__(self, other):
18614 
    return not (self == other)
6531 vikram.rag 18615 
 
18616 
class getAllIgnoredInventoryUpdateItemsList_args:
18617 
  """
18618 
  Attributes:
18619 
   - offset
18620 
   - limit
18621 
  """
18622 
 
18623 
  thrift_spec = (
18624 
    None, # 0
18625 
    (1, TType.I32, 'offset', None, None, ), # 1
18626 
    (2, TType.I32, 'limit', None, None, ), # 2
18627 
  )
18628 
 
18629 
  def __init__(self, offset=None, limit=None,):
18630 
    self.offset = offset
18631 
    self.limit = limit
18632 
 
18633 
  def read(self, iprot):
18634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18636 
      return
18637 
    iprot.readStructBegin()
18638 
    while True:
18639 
      (fname, ftype, fid) = iprot.readFieldBegin()
18640 
      if ftype == TType.STOP:
18641 
        break
18642 
      if fid == 1:
18643 
        if ftype == TType.I32:
18644 
          self.offset = iprot.readI32();
18645 
        else:
18646 
          iprot.skip(ftype)
18647 
      elif fid == 2:
18648 
        if ftype == TType.I32:
18649 
          self.limit = iprot.readI32();
18650 
        else:
18651 
          iprot.skip(ftype)
18652 
      else:
18653 
        iprot.skip(ftype)
18654 
      iprot.readFieldEnd()
18655 
    iprot.readStructEnd()
18656 
 
18657 
  def write(self, oprot):
18658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18660 
      return
18661 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
18662 
    if self.offset is not None:
18663 
      oprot.writeFieldBegin('offset', TType.I32, 1)
18664 
      oprot.writeI32(self.offset)
18665 
      oprot.writeFieldEnd()
18666 
    if self.limit is not None:
18667 
      oprot.writeFieldBegin('limit', TType.I32, 2)
18668 
      oprot.writeI32(self.limit)
18669 
      oprot.writeFieldEnd()
18670 
    oprot.writeFieldStop()
18671 
    oprot.writeStructEnd()
18672 
 
18673 
  def validate(self):
18674 
    return
18675 
 
18676 
 
18677 
  def __repr__(self):
18678 
    L = ['%s=%r' % (key, value)
18679 
      for key, value in self.__dict__.iteritems()]
18680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18681 
 
18682 
  def __eq__(self, other):
18683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18684 
 
18685 
  def __ne__(self, other):
18686 
    return not (self == other)
18687 
 
18688 
class getAllIgnoredInventoryUpdateItemsList_result:
18689 
  """
18690 
  Attributes:
18691 
   - success
18692 
  """
18693 
 
18694 
  thrift_spec = (
18695 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18696 
  )
18697 
 
18698 
  def __init__(self, success=None,):
18699 
    self.success = success
18700 
 
18701 
  def read(self, iprot):
18702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18704 
      return
18705 
    iprot.readStructBegin()
18706 
    while True:
18707 
      (fname, ftype, fid) = iprot.readFieldBegin()
18708 
      if ftype == TType.STOP:
18709 
        break
18710 
      if fid == 0:
18711 
        if ftype == TType.LIST:
18712 
          self.success = []
9155 kshitij.so 18713 
          (_etype370, _size367) = iprot.readListBegin()
18714 
          for _i371 in xrange(_size367):
18715 
            _elem372 = Item()
18716 
            _elem372.read(iprot)
18717 
            self.success.append(_elem372)
6531 vikram.rag 18718 
          iprot.readListEnd()
18719 
        else:
18720 
          iprot.skip(ftype)
18721 
      else:
18722 
        iprot.skip(ftype)
18723 
      iprot.readFieldEnd()
18724 
    iprot.readStructEnd()
18725 
 
18726 
  def write(self, oprot):
18727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18729 
      return
18730 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
18731 
    if self.success is not None:
18732 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18733 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18734 
      for iter373 in self.success:
18735 
        iter373.write(oprot)
6531 vikram.rag 18736 
      oprot.writeListEnd()
18737 
      oprot.writeFieldEnd()
18738 
    oprot.writeFieldStop()
18739 
    oprot.writeStructEnd()
18740 
 
18741 
  def validate(self):
18742 
    return
18743 
 
18744 
 
18745 
  def __repr__(self):
18746 
    L = ['%s=%r' % (key, value)
18747 
      for key, value in self.__dict__.iteritems()]
18748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18749 
 
18750 
  def __eq__(self, other):
18751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18752 
 
18753 
  def __ne__(self, other):
18754 
    return not (self == other)
6805 anupam.sin 18755 
 
6821 amar.kumar 18756 
class getAllAliveItems_args:
18757 
 
18758 
  thrift_spec = (
18759 
  )
18760 
 
18761 
  def read(self, iprot):
18762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18764 
      return
18765 
    iprot.readStructBegin()
18766 
    while True:
18767 
      (fname, ftype, fid) = iprot.readFieldBegin()
18768 
      if ftype == TType.STOP:
18769 
        break
18770 
      else:
18771 
        iprot.skip(ftype)
18772 
      iprot.readFieldEnd()
18773 
    iprot.readStructEnd()
18774 
 
18775 
  def write(self, oprot):
18776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18778 
      return
18779 
    oprot.writeStructBegin('getAllAliveItems_args')
18780 
    oprot.writeFieldStop()
18781 
    oprot.writeStructEnd()
18782 
 
18783 
  def validate(self):
18784 
    return
18785 
 
18786 
 
18787 
  def __repr__(self):
18788 
    L = ['%s=%r' % (key, value)
18789 
      for key, value in self.__dict__.iteritems()]
18790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18791 
 
18792 
  def __eq__(self, other):
18793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18794 
 
18795 
  def __ne__(self, other):
18796 
    return not (self == other)
18797 
 
18798 
class getAllAliveItems_result:
18799 
  """
18800 
  Attributes:
18801 
   - success
18802 
  """
18803 
 
18804 
  thrift_spec = (
18805 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18806 
  )
18807 
 
18808 
  def __init__(self, success=None,):
18809 
    self.success = success
18810 
 
18811 
  def read(self, iprot):
18812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18814 
      return
18815 
    iprot.readStructBegin()
18816 
    while True:
18817 
      (fname, ftype, fid) = iprot.readFieldBegin()
18818 
      if ftype == TType.STOP:
18819 
        break
18820 
      if fid == 0:
18821 
        if ftype == TType.LIST:
18822 
          self.success = []
9155 kshitij.so 18823 
          (_etype377, _size374) = iprot.readListBegin()
18824 
          for _i378 in xrange(_size374):
18825 
            _elem379 = Item()
18826 
            _elem379.read(iprot)
18827 
            self.success.append(_elem379)
6821 amar.kumar 18828 
          iprot.readListEnd()
18829 
        else:
18830 
          iprot.skip(ftype)
18831 
      else:
18832 
        iprot.skip(ftype)
18833 
      iprot.readFieldEnd()
18834 
    iprot.readStructEnd()
18835 
 
18836 
  def write(self, oprot):
18837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18839 
      return
18840 
    oprot.writeStructBegin('getAllAliveItems_result')
18841 
    if self.success is not None:
18842 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18843 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18844 
      for iter380 in self.success:
18845 
        iter380.write(oprot)
6821 amar.kumar 18846 
      oprot.writeListEnd()
18847 
      oprot.writeFieldEnd()
18848 
    oprot.writeFieldStop()
18849 
    oprot.writeStructEnd()
18850 
 
18851 
  def validate(self):
18852 
    return
18853 
 
18854 
 
18855 
  def __repr__(self):
18856 
    L = ['%s=%r' % (key, value)
18857 
      for key, value in self.__dict__.iteritems()]
18858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18859 
 
18860 
  def __eq__(self, other):
18861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18862 
 
18863 
  def __ne__(self, other):
18864 
    return not (self == other)
18865 
 
6805 anupam.sin 18866 
class getInsuranceAmount_args:
18867 
  """
18868 
  Attributes:
18869 
   - itemId
6921 anupam.sin 18870 
   - price
6805 anupam.sin 18871 
   - insurerId
18872 
   - quantity
18873 
  """
18874 
 
18875 
  thrift_spec = (
18876 
    None, # 0
18877 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 18878 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18879 
    (3, TType.I64, 'insurerId', None, None, ), # 3
18880 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 18881 
  )
18882 
 
6921 anupam.sin 18883 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 18884 
    self.itemId = itemId
6921 anupam.sin 18885 
    self.price = price
6805 anupam.sin 18886 
    self.insurerId = insurerId
18887 
    self.quantity = quantity
18888 
 
18889 
  def read(self, iprot):
18890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18892 
      return
18893 
    iprot.readStructBegin()
18894 
    while True:
18895 
      (fname, ftype, fid) = iprot.readFieldBegin()
18896 
      if ftype == TType.STOP:
18897 
        break
18898 
      if fid == 1:
18899 
        if ftype == TType.I64:
18900 
          self.itemId = iprot.readI64();
18901 
        else:
18902 
          iprot.skip(ftype)
18903 
      elif fid == 2:
6921 anupam.sin 18904 
        if ftype == TType.DOUBLE:
18905 
          self.price = iprot.readDouble();
18906 
        else:
18907 
          iprot.skip(ftype)
18908 
      elif fid == 3:
6805 anupam.sin 18909 
        if ftype == TType.I64:
18910 
          self.insurerId = iprot.readI64();
18911 
        else:
18912 
          iprot.skip(ftype)
6921 anupam.sin 18913 
      elif fid == 4:
6805 anupam.sin 18914 
        if ftype == TType.I64:
18915 
          self.quantity = iprot.readI64();
18916 
        else:
18917 
          iprot.skip(ftype)
18918 
      else:
18919 
        iprot.skip(ftype)
18920 
      iprot.readFieldEnd()
18921 
    iprot.readStructEnd()
18922 
 
18923 
  def write(self, oprot):
18924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18926 
      return
18927 
    oprot.writeStructBegin('getInsuranceAmount_args')
18928 
    if self.itemId is not None:
18929 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18930 
      oprot.writeI64(self.itemId)
18931 
      oprot.writeFieldEnd()
6921 anupam.sin 18932 
    if self.price is not None:
18933 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18934 
      oprot.writeDouble(self.price)
18935 
      oprot.writeFieldEnd()
6805 anupam.sin 18936 
    if self.insurerId is not None:
6921 anupam.sin 18937 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 18938 
      oprot.writeI64(self.insurerId)
18939 
      oprot.writeFieldEnd()
18940 
    if self.quantity is not None:
6921 anupam.sin 18941 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 18942 
      oprot.writeI64(self.quantity)
18943 
      oprot.writeFieldEnd()
18944 
    oprot.writeFieldStop()
18945 
    oprot.writeStructEnd()
18946 
 
18947 
  def validate(self):
18948 
    return
18949 
 
18950 
 
18951 
  def __repr__(self):
18952 
    L = ['%s=%r' % (key, value)
18953 
      for key, value in self.__dict__.iteritems()]
18954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18955 
 
18956 
  def __eq__(self, other):
18957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18958 
 
18959 
  def __ne__(self, other):
18960 
    return not (self == other)
18961 
 
18962 
class getInsuranceAmount_result:
18963 
  """
18964 
  Attributes:
18965 
   - success
18966 
  """
18967 
 
18968 
  thrift_spec = (
18969 
    (0, TType.I64, 'success', None, None, ), # 0
18970 
  )
18971 
 
18972 
  def __init__(self, success=None,):
18973 
    self.success = success
18974 
 
18975 
  def read(self, iprot):
18976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18978 
      return
18979 
    iprot.readStructBegin()
18980 
    while True:
18981 
      (fname, ftype, fid) = iprot.readFieldBegin()
18982 
      if ftype == TType.STOP:
18983 
        break
18984 
      if fid == 0:
18985 
        if ftype == TType.I64:
18986 
          self.success = iprot.readI64();
18987 
        else:
18988 
          iprot.skip(ftype)
18989 
      else:
18990 
        iprot.skip(ftype)
18991 
      iprot.readFieldEnd()
18992 
    iprot.readStructEnd()
18993 
 
18994 
  def write(self, oprot):
18995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18997 
      return
18998 
    oprot.writeStructBegin('getInsuranceAmount_result')
18999 
    if self.success is not None:
19000 
      oprot.writeFieldBegin('success', TType.I64, 0)
19001 
      oprot.writeI64(self.success)
19002 
      oprot.writeFieldEnd()
19003 
    oprot.writeFieldStop()
19004 
    oprot.writeStructEnd()
19005 
 
19006 
  def validate(self):
19007 
    return
19008 
 
19009 
 
19010 
  def __repr__(self):
19011 
    L = ['%s=%r' % (key, value)
19012 
      for key, value in self.__dict__.iteritems()]
19013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19014 
 
19015 
  def __eq__(self, other):
19016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19017 
 
19018 
  def __ne__(self, other):
19019 
    return not (self == other)
19020 
 
19021 
class getInsurer_args:
19022 
  """
19023 
  Attributes:
19024 
   - insurerId
19025 
  """
19026 
 
19027 
  thrift_spec = (
19028 
    None, # 0
19029 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19030 
  )
19031 
 
19032 
  def __init__(self, insurerId=None,):
19033 
    self.insurerId = insurerId
19034 
 
19035 
  def read(self, iprot):
19036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19038 
      return
19039 
    iprot.readStructBegin()
19040 
    while True:
19041 
      (fname, ftype, fid) = iprot.readFieldBegin()
19042 
      if ftype == TType.STOP:
19043 
        break
19044 
      if fid == 1:
19045 
        if ftype == TType.I64:
19046 
          self.insurerId = iprot.readI64();
19047 
        else:
19048 
          iprot.skip(ftype)
19049 
      else:
19050 
        iprot.skip(ftype)
19051 
      iprot.readFieldEnd()
19052 
    iprot.readStructEnd()
19053 
 
19054 
  def write(self, oprot):
19055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19057 
      return
19058 
    oprot.writeStructBegin('getInsurer_args')
19059 
    if self.insurerId is not None:
19060 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19061 
      oprot.writeI64(self.insurerId)
19062 
      oprot.writeFieldEnd()
19063 
    oprot.writeFieldStop()
19064 
    oprot.writeStructEnd()
19065 
 
19066 
  def validate(self):
19067 
    return
19068 
 
19069 
 
19070 
  def __repr__(self):
19071 
    L = ['%s=%r' % (key, value)
19072 
      for key, value in self.__dict__.iteritems()]
19073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19074 
 
19075 
  def __eq__(self, other):
19076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19077 
 
19078 
  def __ne__(self, other):
19079 
    return not (self == other)
19080 
 
19081 
class getInsurer_result:
19082 
  """
19083 
  Attributes:
19084 
   - success
19085 
  """
19086 
 
19087 
  thrift_spec = (
19088 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
19089 
  )
19090 
 
19091 
  def __init__(self, success=None,):
19092 
    self.success = success
19093 
 
19094 
  def read(self, iprot):
19095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19097 
      return
19098 
    iprot.readStructBegin()
19099 
    while True:
19100 
      (fname, ftype, fid) = iprot.readFieldBegin()
19101 
      if ftype == TType.STOP:
19102 
        break
19103 
      if fid == 0:
19104 
        if ftype == TType.STRUCT:
19105 
          self.success = Insurer()
19106 
          self.success.read(iprot)
19107 
        else:
19108 
          iprot.skip(ftype)
19109 
      else:
19110 
        iprot.skip(ftype)
19111 
      iprot.readFieldEnd()
19112 
    iprot.readStructEnd()
19113 
 
19114 
  def write(self, oprot):
19115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19117 
      return
19118 
    oprot.writeStructBegin('getInsurer_result')
19119 
    if self.success is not None:
19120 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19121 
      self.success.write(oprot)
19122 
      oprot.writeFieldEnd()
19123 
    oprot.writeFieldStop()
19124 
    oprot.writeStructEnd()
19125 
 
19126 
  def validate(self):
19127 
    return
19128 
 
19129 
 
19130 
  def __repr__(self):
19131 
    L = ['%s=%r' % (key, value)
19132 
      for key, value in self.__dict__.iteritems()]
19133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19134 
 
19135 
  def __eq__(self, other):
19136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19137 
 
19138 
  def __ne__(self, other):
19139 
    return not (self == other)
6838 vikram.rag 19140 
 
19141 
class getAllInsurers_args:
19142 
 
19143 
  thrift_spec = (
19144 
  )
19145 
 
19146 
  def read(self, iprot):
19147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19149 
      return
19150 
    iprot.readStructBegin()
19151 
    while True:
19152 
      (fname, ftype, fid) = iprot.readFieldBegin()
19153 
      if ftype == TType.STOP:
19154 
        break
19155 
      else:
19156 
        iprot.skip(ftype)
19157 
      iprot.readFieldEnd()
19158 
    iprot.readStructEnd()
19159 
 
19160 
  def write(self, oprot):
19161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19163 
      return
19164 
    oprot.writeStructBegin('getAllInsurers_args')
19165 
    oprot.writeFieldStop()
19166 
    oprot.writeStructEnd()
19167 
 
19168 
  def validate(self):
19169 
    return
19170 
 
19171 
 
19172 
  def __repr__(self):
19173 
    L = ['%s=%r' % (key, value)
19174 
      for key, value in self.__dict__.iteritems()]
19175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19176 
 
19177 
  def __eq__(self, other):
19178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19179 
 
19180 
  def __ne__(self, other):
19181 
    return not (self == other)
19182 
 
19183 
class getAllInsurers_result:
19184 
  """
19185 
  Attributes:
19186 
   - success
19187 
  """
19188 
 
19189 
  thrift_spec = (
19190 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
19191 
  )
19192 
 
19193 
  def __init__(self, success=None,):
19194 
    self.success = success
19195 
 
19196 
  def read(self, iprot):
19197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19199 
      return
19200 
    iprot.readStructBegin()
19201 
    while True:
19202 
      (fname, ftype, fid) = iprot.readFieldBegin()
19203 
      if ftype == TType.STOP:
19204 
        break
19205 
      if fid == 0:
19206 
        if ftype == TType.LIST:
19207 
          self.success = []
9155 kshitij.so 19208 
          (_etype384, _size381) = iprot.readListBegin()
19209 
          for _i385 in xrange(_size381):
19210 
            _elem386 = Insurer()
19211 
            _elem386.read(iprot)
19212 
            self.success.append(_elem386)
6838 vikram.rag 19213 
          iprot.readListEnd()
19214 
        else:
19215 
          iprot.skip(ftype)
19216 
      else:
19217 
        iprot.skip(ftype)
19218 
      iprot.readFieldEnd()
19219 
    iprot.readStructEnd()
19220 
 
19221 
  def write(self, oprot):
19222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19224 
      return
19225 
    oprot.writeStructBegin('getAllInsurers_result')
19226 
    if self.success is not None:
19227 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19228 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19229 
      for iter387 in self.success:
19230 
        iter387.write(oprot)
6838 vikram.rag 19231 
      oprot.writeListEnd()
19232 
      oprot.writeFieldEnd()
19233 
    oprot.writeFieldStop()
19234 
    oprot.writeStructEnd()
19235 
 
19236 
  def validate(self):
19237 
    return
19238 
 
19239 
 
19240 
  def __repr__(self):
19241 
    L = ['%s=%r' % (key, value)
19242 
      for key, value in self.__dict__.iteritems()]
19243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19244 
 
19245 
  def __eq__(self, other):
19246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19247 
 
19248 
  def __ne__(self, other):
19249 
    return not (self == other)
6962 rajveer 19250 
 
19251 
class updateInsuranceDeclaredAmount_args:
19252 
  """
19253 
  Attributes:
19254 
   - insurerId
19255 
   - amount
19256 
  """
19257 
 
19258 
  thrift_spec = (
19259 
    None, # 0
19260 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19261 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
19262 
  )
19263 
 
19264 
  def __init__(self, insurerId=None, amount=None,):
19265 
    self.insurerId = insurerId
19266 
    self.amount = amount
19267 
 
19268 
  def read(self, iprot):
19269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19271 
      return
19272 
    iprot.readStructBegin()
19273 
    while True:
19274 
      (fname, ftype, fid) = iprot.readFieldBegin()
19275 
      if ftype == TType.STOP:
19276 
        break
19277 
      if fid == 1:
19278 
        if ftype == TType.I64:
19279 
          self.insurerId = iprot.readI64();
19280 
        else:
19281 
          iprot.skip(ftype)
19282 
      elif fid == 2:
19283 
        if ftype == TType.DOUBLE:
19284 
          self.amount = iprot.readDouble();
19285 
        else:
19286 
          iprot.skip(ftype)
19287 
      else:
19288 
        iprot.skip(ftype)
19289 
      iprot.readFieldEnd()
19290 
    iprot.readStructEnd()
19291 
 
19292 
  def write(self, oprot):
19293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19295 
      return
19296 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
19297 
    if self.insurerId is not None:
19298 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19299 
      oprot.writeI64(self.insurerId)
19300 
      oprot.writeFieldEnd()
19301 
    if self.amount is not None:
19302 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
19303 
      oprot.writeDouble(self.amount)
19304 
      oprot.writeFieldEnd()
19305 
    oprot.writeFieldStop()
19306 
    oprot.writeStructEnd()
19307 
 
19308 
  def validate(self):
19309 
    return
19310 
 
19311 
 
19312 
  def __repr__(self):
19313 
    L = ['%s=%r' % (key, value)
19314 
      for key, value in self.__dict__.iteritems()]
19315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19316 
 
19317 
  def __eq__(self, other):
19318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19319 
 
19320 
  def __ne__(self, other):
19321 
    return not (self == other)
19322 
 
19323 
class updateInsuranceDeclaredAmount_result:
19324 
 
19325 
  thrift_spec = (
19326 
  )
19327 
 
19328 
  def read(self, iprot):
19329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19331 
      return
19332 
    iprot.readStructBegin()
19333 
    while True:
19334 
      (fname, ftype, fid) = iprot.readFieldBegin()
19335 
      if ftype == TType.STOP:
19336 
        break
19337 
      else:
19338 
        iprot.skip(ftype)
19339 
      iprot.readFieldEnd()
19340 
    iprot.readStructEnd()
19341 
 
19342 
  def write(self, oprot):
19343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19345 
      return
19346 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
19347 
    oprot.writeFieldStop()
19348 
    oprot.writeStructEnd()
19349 
 
19350 
  def validate(self):
19351 
    return
19352 
 
19353 
 
19354 
  def __repr__(self):
19355 
    L = ['%s=%r' % (key, value)
19356 
      for key, value in self.__dict__.iteritems()]
19357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19358 
 
19359 
  def __eq__(self, other):
19360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19361 
 
19362 
  def __ne__(self, other):
19363 
    return not (self == other)
7190 amar.kumar 19364 
 
19365 
class getFreebieForItem_args:
19366 
  """
19367 
  Attributes:
19368 
   - itemId
19369 
  """
19370 
 
19371 
  thrift_spec = (
19372 
    None, # 0
19373 
    (1, TType.I64, 'itemId', None, None, ), # 1
19374 
  )
19375 
 
19376 
  def __init__(self, itemId=None,):
19377 
    self.itemId = itemId
19378 
 
19379 
  def read(self, iprot):
19380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19382 
      return
19383 
    iprot.readStructBegin()
19384 
    while True:
19385 
      (fname, ftype, fid) = iprot.readFieldBegin()
19386 
      if ftype == TType.STOP:
19387 
        break
19388 
      if fid == 1:
19389 
        if ftype == TType.I64:
19390 
          self.itemId = iprot.readI64();
19391 
        else:
19392 
          iprot.skip(ftype)
19393 
      else:
19394 
        iprot.skip(ftype)
19395 
      iprot.readFieldEnd()
19396 
    iprot.readStructEnd()
19397 
 
19398 
  def write(self, oprot):
19399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19401 
      return
19402 
    oprot.writeStructBegin('getFreebieForItem_args')
19403 
    if self.itemId is not None:
19404 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19405 
      oprot.writeI64(self.itemId)
19406 
      oprot.writeFieldEnd()
19407 
    oprot.writeFieldStop()
19408 
    oprot.writeStructEnd()
19409 
 
19410 
  def validate(self):
19411 
    return
19412 
 
19413 
 
19414 
  def __repr__(self):
19415 
    L = ['%s=%r' % (key, value)
19416 
      for key, value in self.__dict__.iteritems()]
19417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19418 
 
19419 
  def __eq__(self, other):
19420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19421 
 
19422 
  def __ne__(self, other):
19423 
    return not (self == other)
19424 
 
19425 
class getFreebieForItem_result:
19426 
  """
19427 
  Attributes:
19428 
   - success
19429 
  """
19430 
 
19431 
  thrift_spec = (
19432 
    (0, TType.I64, 'success', None, None, ), # 0
19433 
  )
19434 
 
19435 
  def __init__(self, success=None,):
19436 
    self.success = success
19437 
 
19438 
  def read(self, iprot):
19439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19441 
      return
19442 
    iprot.readStructBegin()
19443 
    while True:
19444 
      (fname, ftype, fid) = iprot.readFieldBegin()
19445 
      if ftype == TType.STOP:
19446 
        break
19447 
      if fid == 0:
19448 
        if ftype == TType.I64:
19449 
          self.success = iprot.readI64();
19450 
        else:
19451 
          iprot.skip(ftype)
19452 
      else:
19453 
        iprot.skip(ftype)
19454 
      iprot.readFieldEnd()
19455 
    iprot.readStructEnd()
19456 
 
19457 
  def write(self, oprot):
19458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19460 
      return
19461 
    oprot.writeStructBegin('getFreebieForItem_result')
19462 
    if self.success is not None:
19463 
      oprot.writeFieldBegin('success', TType.I64, 0)
19464 
      oprot.writeI64(self.success)
19465 
      oprot.writeFieldEnd()
19466 
    oprot.writeFieldStop()
19467 
    oprot.writeStructEnd()
19468 
 
19469 
  def validate(self):
19470 
    return
19471 
 
19472 
 
19473 
  def __repr__(self):
19474 
    L = ['%s=%r' % (key, value)
19475 
      for key, value in self.__dict__.iteritems()]
19476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19477 
 
19478 
  def __eq__(self, other):
19479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19480 
 
19481 
  def __ne__(self, other):
19482 
    return not (self == other)
19483 
 
19484 
class addOrUpdateFreebieForItem_args:
19485 
  """
19486 
  Attributes:
19487 
   - freebieItem
19488 
  """
19489 
 
19490 
  thrift_spec = (
19491 
    None, # 0
19492 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
19493 
  )
19494 
 
19495 
  def __init__(self, freebieItem=None,):
19496 
    self.freebieItem = freebieItem
19497 
 
19498 
  def read(self, iprot):
19499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19501 
      return
19502 
    iprot.readStructBegin()
19503 
    while True:
19504 
      (fname, ftype, fid) = iprot.readFieldBegin()
19505 
      if ftype == TType.STOP:
19506 
        break
19507 
      if fid == 1:
19508 
        if ftype == TType.STRUCT:
19509 
          self.freebieItem = FreebieItem()
19510 
          self.freebieItem.read(iprot)
19511 
        else:
19512 
          iprot.skip(ftype)
19513 
      else:
19514 
        iprot.skip(ftype)
19515 
      iprot.readFieldEnd()
19516 
    iprot.readStructEnd()
19517 
 
19518 
  def write(self, oprot):
19519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19521 
      return
19522 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
19523 
    if self.freebieItem is not None:
19524 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
19525 
      self.freebieItem.write(oprot)
19526 
      oprot.writeFieldEnd()
19527 
    oprot.writeFieldStop()
19528 
    oprot.writeStructEnd()
19529 
 
19530 
  def validate(self):
19531 
    return
19532 
 
19533 
 
19534 
  def __repr__(self):
19535 
    L = ['%s=%r' % (key, value)
19536 
      for key, value in self.__dict__.iteritems()]
19537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19538 
 
19539 
  def __eq__(self, other):
19540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19541 
 
19542 
  def __ne__(self, other):
19543 
    return not (self == other)
19544 
 
19545 
class addOrUpdateFreebieForItem_result:
19546 
 
19547 
  thrift_spec = (
19548 
  )
19549 
 
19550 
  def read(self, iprot):
19551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19553 
      return
19554 
    iprot.readStructBegin()
19555 
    while True:
19556 
      (fname, ftype, fid) = iprot.readFieldBegin()
19557 
      if ftype == TType.STOP:
19558 
        break
19559 
      else:
19560 
        iprot.skip(ftype)
19561 
      iprot.readFieldEnd()
19562 
    iprot.readStructEnd()
19563 
 
19564 
  def write(self, oprot):
19565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19567 
      return
19568 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
19569 
    oprot.writeFieldStop()
19570 
    oprot.writeStructEnd()
19571 
 
19572 
  def validate(self):
19573 
    return
19574 
 
19575 
 
19576 
  def __repr__(self):
19577 
    L = ['%s=%r' % (key, value)
19578 
      for key, value in self.__dict__.iteritems()]
19579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19580 
 
19581 
  def __eq__(self, other):
19582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19583 
 
19584 
  def __ne__(self, other):
19585 
    return not (self == other)
7256 rajveer 19586 
 
7272 amit.gupta 19587 
class addOrUpdateBrandInfo_args:
19588 
  """
19589 
  Attributes:
19590 
   - brandInfo
19591 
  """
19592 
 
19593 
  thrift_spec = (
19594 
    None, # 0
19595 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
19596 
  )
19597 
 
19598 
  def __init__(self, brandInfo=None,):
19599 
    self.brandInfo = brandInfo
19600 
 
19601 
  def read(self, iprot):
19602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19604 
      return
19605 
    iprot.readStructBegin()
19606 
    while True:
19607 
      (fname, ftype, fid) = iprot.readFieldBegin()
19608 
      if ftype == TType.STOP:
19609 
        break
19610 
      if fid == 1:
19611 
        if ftype == TType.STRUCT:
19612 
          self.brandInfo = BrandInfo()
19613 
          self.brandInfo.read(iprot)
19614 
        else:
19615 
          iprot.skip(ftype)
19616 
      else:
19617 
        iprot.skip(ftype)
19618 
      iprot.readFieldEnd()
19619 
    iprot.readStructEnd()
19620 
 
19621 
  def write(self, oprot):
19622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19624 
      return
19625 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
19626 
    if self.brandInfo is not None:
19627 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
19628 
      self.brandInfo.write(oprot)
19629 
      oprot.writeFieldEnd()
19630 
    oprot.writeFieldStop()
19631 
    oprot.writeStructEnd()
19632 
 
19633 
  def validate(self):
19634 
    return
19635 
 
19636 
 
19637 
  def __repr__(self):
19638 
    L = ['%s=%r' % (key, value)
19639 
      for key, value in self.__dict__.iteritems()]
19640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19641 
 
19642 
  def __eq__(self, other):
19643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19644 
 
19645 
  def __ne__(self, other):
19646 
    return not (self == other)
19647 
 
19648 
class addOrUpdateBrandInfo_result:
19649 
 
19650 
  thrift_spec = (
19651 
  )
19652 
 
19653 
  def read(self, iprot):
19654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19656 
      return
19657 
    iprot.readStructBegin()
19658 
    while True:
19659 
      (fname, ftype, fid) = iprot.readFieldBegin()
19660 
      if ftype == TType.STOP:
19661 
        break
19662 
      else:
19663 
        iprot.skip(ftype)
19664 
      iprot.readFieldEnd()
19665 
    iprot.readStructEnd()
19666 
 
19667 
  def write(self, oprot):
19668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19670 
      return
19671 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
19672 
    oprot.writeFieldStop()
19673 
    oprot.writeStructEnd()
19674 
 
19675 
  def validate(self):
19676 
    return
19677 
 
19678 
 
19679 
  def __repr__(self):
19680 
    L = ['%s=%r' % (key, value)
19681 
      for key, value in self.__dict__.iteritems()]
19682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19683 
 
19684 
  def __eq__(self, other):
19685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19686 
 
19687 
  def __ne__(self, other):
19688 
    return not (self == other)
19689 
 
19690 
class getBrandInfo_args:
19691 
 
19692 
  thrift_spec = (
19693 
  )
19694 
 
19695 
  def read(self, iprot):
19696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19698 
      return
19699 
    iprot.readStructBegin()
19700 
    while True:
19701 
      (fname, ftype, fid) = iprot.readFieldBegin()
19702 
      if ftype == TType.STOP:
19703 
        break
19704 
      else:
19705 
        iprot.skip(ftype)
19706 
      iprot.readFieldEnd()
19707 
    iprot.readStructEnd()
19708 
 
19709 
  def write(self, oprot):
19710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19712 
      return
19713 
    oprot.writeStructBegin('getBrandInfo_args')
19714 
    oprot.writeFieldStop()
19715 
    oprot.writeStructEnd()
19716 
 
19717 
  def validate(self):
19718 
    return
19719 
 
19720 
 
19721 
  def __repr__(self):
19722 
    L = ['%s=%r' % (key, value)
19723 
      for key, value in self.__dict__.iteritems()]
19724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19725 
 
19726 
  def __eq__(self, other):
19727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19728 
 
19729 
  def __ne__(self, other):
19730 
    return not (self == other)
19731 
 
19732 
class getBrandInfo_result:
19733 
  """
19734 
  Attributes:
19735 
   - success
19736 
  """
19737 
 
19738 
  thrift_spec = (
19739 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
19740 
  )
19741 
 
19742 
  def __init__(self, success=None,):
19743 
    self.success = success
19744 
 
19745 
  def read(self, iprot):
19746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19748 
      return
19749 
    iprot.readStructBegin()
19750 
    while True:
19751 
      (fname, ftype, fid) = iprot.readFieldBegin()
19752 
      if ftype == TType.STOP:
19753 
        break
19754 
      if fid == 0:
19755 
        if ftype == TType.MAP:
19756 
          self.success = {}
9155 kshitij.so 19757 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
19758 
          for _i392 in xrange(_size388):
19759 
            _key393 = iprot.readString();
19760 
            _val394 = BrandInfo()
19761 
            _val394.read(iprot)
19762 
            self.success[_key393] = _val394
7272 amit.gupta 19763 
          iprot.readMapEnd()
19764 
        else:
19765 
          iprot.skip(ftype)
19766 
      else:
19767 
        iprot.skip(ftype)
19768 
      iprot.readFieldEnd()
19769 
    iprot.readStructEnd()
19770 
 
19771 
  def write(self, oprot):
19772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19774 
      return
19775 
    oprot.writeStructBegin('getBrandInfo_result')
19776 
    if self.success is not None:
19777 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19778 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 19779 
      for kiter395,viter396 in self.success.items():
19780 
        oprot.writeString(kiter395)
19781 
        viter396.write(oprot)
7272 amit.gupta 19782 
      oprot.writeMapEnd()
19783 
      oprot.writeFieldEnd()
19784 
    oprot.writeFieldStop()
19785 
    oprot.writeStructEnd()
19786 
 
19787 
  def validate(self):
19788 
    return
19789 
 
19790 
 
19791 
  def __repr__(self):
19792 
    L = ['%s=%r' % (key, value)
19793 
      for key, value in self.__dict__.iteritems()]
19794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19795 
 
19796 
  def __eq__(self, other):
19797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19798 
 
19799 
  def __ne__(self, other):
19800 
    return not (self == other)
19801 
 
7256 rajveer 19802 
class getStorePricing_args:
19803 
  """
19804 
  Attributes:
19805 
   - itemId
19806 
  """
19807 
 
19808 
  thrift_spec = (
19809 
    None, # 0
19810 
    (1, TType.I64, 'itemId', None, None, ), # 1
19811 
  )
19812 
 
19813 
  def __init__(self, itemId=None,):
19814 
    self.itemId = itemId
19815 
 
19816 
  def read(self, iprot):
19817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19819 
      return
19820 
    iprot.readStructBegin()
19821 
    while True:
19822 
      (fname, ftype, fid) = iprot.readFieldBegin()
19823 
      if ftype == TType.STOP:
19824 
        break
19825 
      if fid == 1:
19826 
        if ftype == TType.I64:
19827 
          self.itemId = iprot.readI64();
19828 
        else:
19829 
          iprot.skip(ftype)
19830 
      else:
19831 
        iprot.skip(ftype)
19832 
      iprot.readFieldEnd()
19833 
    iprot.readStructEnd()
19834 
 
19835 
  def write(self, oprot):
19836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19838 
      return
19839 
    oprot.writeStructBegin('getStorePricing_args')
19840 
    if self.itemId is not None:
19841 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19842 
      oprot.writeI64(self.itemId)
19843 
      oprot.writeFieldEnd()
19844 
    oprot.writeFieldStop()
19845 
    oprot.writeStructEnd()
19846 
 
19847 
  def validate(self):
19848 
    return
19849 
 
19850 
 
19851 
  def __repr__(self):
19852 
    L = ['%s=%r' % (key, value)
19853 
      for key, value in self.__dict__.iteritems()]
19854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19855 
 
19856 
  def __eq__(self, other):
19857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19858 
 
19859 
  def __ne__(self, other):
19860 
    return not (self == other)
19861 
 
19862 
class getStorePricing_result:
19863 
  """
19864 
  Attributes:
19865 
   - success
19866 
  """
19867 
 
19868 
  thrift_spec = (
19869 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
19870 
  )
19871 
 
19872 
  def __init__(self, success=None,):
19873 
    self.success = success
19874 
 
19875 
  def read(self, iprot):
19876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19878 
      return
19879 
    iprot.readStructBegin()
19880 
    while True:
19881 
      (fname, ftype, fid) = iprot.readFieldBegin()
19882 
      if ftype == TType.STOP:
19883 
        break
19884 
      if fid == 0:
19885 
        if ftype == TType.STRUCT:
19886 
          self.success = StorePricing()
19887 
          self.success.read(iprot)
19888 
        else:
19889 
          iprot.skip(ftype)
19890 
      else:
19891 
        iprot.skip(ftype)
19892 
      iprot.readFieldEnd()
19893 
    iprot.readStructEnd()
19894 
 
19895 
  def write(self, oprot):
19896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19898 
      return
19899 
    oprot.writeStructBegin('getStorePricing_result')
19900 
    if self.success is not None:
19901 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19902 
      self.success.write(oprot)
19903 
      oprot.writeFieldEnd()
19904 
    oprot.writeFieldStop()
19905 
    oprot.writeStructEnd()
19906 
 
19907 
  def validate(self):
19908 
    return
19909 
 
19910 
 
19911 
  def __repr__(self):
19912 
    L = ['%s=%r' % (key, value)
19913 
      for key, value in self.__dict__.iteritems()]
19914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19915 
 
19916 
  def __eq__(self, other):
19917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19918 
 
19919 
  def __ne__(self, other):
19920 
    return not (self == other)
7265 rajveer 19921 
 
7306 rajveer 19922 
class getStorePricings_args:
19923 
  """
19924 
  Attributes:
19925 
   - itemIds
19926 
  """
19927 
 
19928 
  thrift_spec = (
19929 
    None, # 0
19930 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19931 
  )
19932 
 
19933 
  def __init__(self, itemIds=None,):
19934 
    self.itemIds = itemIds
19935 
 
19936 
  def read(self, iprot):
19937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19939 
      return
19940 
    iprot.readStructBegin()
19941 
    while True:
19942 
      (fname, ftype, fid) = iprot.readFieldBegin()
19943 
      if ftype == TType.STOP:
19944 
        break
19945 
      if fid == 1:
19946 
        if ftype == TType.LIST:
19947 
          self.itemIds = []
9155 kshitij.so 19948 
          (_etype400, _size397) = iprot.readListBegin()
19949 
          for _i401 in xrange(_size397):
19950 
            _elem402 = iprot.readI64();
19951 
            self.itemIds.append(_elem402)
7306 rajveer 19952 
          iprot.readListEnd()
19953 
        else:
19954 
          iprot.skip(ftype)
19955 
      else:
19956 
        iprot.skip(ftype)
19957 
      iprot.readFieldEnd()
19958 
    iprot.readStructEnd()
19959 
 
19960 
  def write(self, oprot):
19961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19963 
      return
19964 
    oprot.writeStructBegin('getStorePricings_args')
19965 
    if self.itemIds is not None:
19966 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19967 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 19968 
      for iter403 in self.itemIds:
19969 
        oprot.writeI64(iter403)
7306 rajveer 19970 
      oprot.writeListEnd()
19971 
      oprot.writeFieldEnd()
19972 
    oprot.writeFieldStop()
19973 
    oprot.writeStructEnd()
19974 
 
19975 
  def validate(self):
19976 
    return
19977 
 
19978 
 
19979 
  def __repr__(self):
19980 
    L = ['%s=%r' % (key, value)
19981 
      for key, value in self.__dict__.iteritems()]
19982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19983 
 
19984 
  def __eq__(self, other):
19985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19986 
 
19987 
  def __ne__(self, other):
19988 
    return not (self == other)
19989 
 
19990 
class getStorePricings_result:
19991 
  """
19992 
  Attributes:
19993 
   - success
19994 
  """
19995 
 
19996 
  thrift_spec = (
19997 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
19998 
  )
19999 
 
20000 
  def __init__(self, success=None,):
20001 
    self.success = success
20002 
 
20003 
  def read(self, iprot):
20004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20006 
      return
20007 
    iprot.readStructBegin()
20008 
    while True:
20009 
      (fname, ftype, fid) = iprot.readFieldBegin()
20010 
      if ftype == TType.STOP:
20011 
        break
20012 
      if fid == 0:
20013 
        if ftype == TType.LIST:
20014 
          self.success = []
9155 kshitij.so 20015 
          (_etype407, _size404) = iprot.readListBegin()
20016 
          for _i408 in xrange(_size404):
20017 
            _elem409 = StorePricing()
20018 
            _elem409.read(iprot)
20019 
            self.success.append(_elem409)
7306 rajveer 20020 
          iprot.readListEnd()
20021 
        else:
20022 
          iprot.skip(ftype)
20023 
      else:
20024 
        iprot.skip(ftype)
20025 
      iprot.readFieldEnd()
20026 
    iprot.readStructEnd()
20027 
 
20028 
  def write(self, oprot):
20029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20031 
      return
20032 
    oprot.writeStructBegin('getStorePricings_result')
20033 
    if self.success is not None:
20034 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20035 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20036 
      for iter410 in self.success:
20037 
        iter410.write(oprot)
7306 rajveer 20038 
      oprot.writeListEnd()
20039 
      oprot.writeFieldEnd()
20040 
    oprot.writeFieldStop()
20041 
    oprot.writeStructEnd()
20042 
 
20043 
  def validate(self):
20044 
    return
20045 
 
20046 
 
20047 
  def __repr__(self):
20048 
    L = ['%s=%r' % (key, value)
20049 
      for key, value in self.__dict__.iteritems()]
20050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20051 
 
20052 
  def __eq__(self, other):
20053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20054 
 
20055 
  def __ne__(self, other):
20056 
    return not (self == other)
20057 
 
7265 rajveer 20058 
class updateStorePricing_args:
20059 
  """
20060 
  Attributes:
20061 
   - sp
7382 rajveer 20062 
   - allColors
7265 rajveer 20063 
  """
20064 
 
20065 
  thrift_spec = (
20066 
    None, # 0
20067 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 20068 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 20069 
  )
20070 
 
7382 rajveer 20071 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 20072 
    self.sp = sp
7382 rajveer 20073 
    self.allColors = allColors
7265 rajveer 20074 
 
20075 
  def read(self, iprot):
20076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20078 
      return
20079 
    iprot.readStructBegin()
20080 
    while True:
20081 
      (fname, ftype, fid) = iprot.readFieldBegin()
20082 
      if ftype == TType.STOP:
20083 
        break
20084 
      if fid == 1:
20085 
        if ftype == TType.STRUCT:
20086 
          self.sp = StorePricing()
20087 
          self.sp.read(iprot)
20088 
        else:
20089 
          iprot.skip(ftype)
7382 rajveer 20090 
      elif fid == 2:
20091 
        if ftype == TType.BOOL:
20092 
          self.allColors = iprot.readBool();
20093 
        else:
20094 
          iprot.skip(ftype)
7265 rajveer 20095 
      else:
20096 
        iprot.skip(ftype)
20097 
      iprot.readFieldEnd()
20098 
    iprot.readStructEnd()
20099 
 
20100 
  def write(self, oprot):
20101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20103 
      return
20104 
    oprot.writeStructBegin('updateStorePricing_args')
20105 
    if self.sp is not None:
20106 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
20107 
      self.sp.write(oprot)
20108 
      oprot.writeFieldEnd()
7382 rajveer 20109 
    if self.allColors is not None:
20110 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
20111 
      oprot.writeBool(self.allColors)
20112 
      oprot.writeFieldEnd()
7265 rajveer 20113 
    oprot.writeFieldStop()
20114 
    oprot.writeStructEnd()
20115 
 
20116 
  def validate(self):
20117 
    return
20118 
 
20119 
 
20120 
  def __repr__(self):
20121 
    L = ['%s=%r' % (key, value)
20122 
      for key, value in self.__dict__.iteritems()]
20123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20124 
 
20125 
  def __eq__(self, other):
20126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20127 
 
20128 
  def __ne__(self, other):
20129 
    return not (self == other)
20130 
 
20131 
class updateStorePricing_result:
20132 
 
20133 
  thrift_spec = (
20134 
  )
20135 
 
20136 
  def read(self, iprot):
20137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20139 
      return
20140 
    iprot.readStructBegin()
20141 
    while True:
20142 
      (fname, ftype, fid) = iprot.readFieldBegin()
20143 
      if ftype == TType.STOP:
20144 
        break
20145 
      else:
20146 
        iprot.skip(ftype)
20147 
      iprot.readFieldEnd()
20148 
    iprot.readStructEnd()
20149 
 
20150 
  def write(self, oprot):
20151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20153 
      return
20154 
    oprot.writeStructBegin('updateStorePricing_result')
20155 
    oprot.writeFieldStop()
20156 
    oprot.writeStructEnd()
20157 
 
20158 
  def validate(self):
20159 
    return
20160 
 
20161 
 
20162 
  def __repr__(self):
20163 
    L = ['%s=%r' % (key, value)
20164 
      for key, value in self.__dict__.iteritems()]
20165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20166 
 
20167 
  def __eq__(self, other):
20168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20169 
 
20170 
  def __ne__(self, other):
20171 
    return not (self == other)
7281 kshitij.so 20172 
 
20173 
class getAllAmazonListedItems_args:
20174 
 
20175 
  thrift_spec = (
20176 
  )
20177 
 
20178 
  def read(self, iprot):
20179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20181 
      return
20182 
    iprot.readStructBegin()
20183 
    while True:
20184 
      (fname, ftype, fid) = iprot.readFieldBegin()
20185 
      if ftype == TType.STOP:
20186 
        break
20187 
      else:
20188 
        iprot.skip(ftype)
20189 
      iprot.readFieldEnd()
20190 
    iprot.readStructEnd()
20191 
 
20192 
  def write(self, oprot):
20193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20195 
      return
20196 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
20197 
    oprot.writeFieldStop()
20198 
    oprot.writeStructEnd()
20199 
 
20200 
  def validate(self):
20201 
    return
20202 
 
20203 
 
20204 
  def __repr__(self):
20205 
    L = ['%s=%r' % (key, value)
20206 
      for key, value in self.__dict__.iteritems()]
20207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20208 
 
20209 
  def __eq__(self, other):
20210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20211 
 
20212 
  def __ne__(self, other):
20213 
    return not (self == other)
20214 
 
20215 
class getAllAmazonListedItems_result:
20216 
  """
20217 
  Attributes:
20218 
   - success
20219 
  """
20220 
 
20221 
  thrift_spec = (
20222 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20223 
  )
20224 
 
20225 
  def __init__(self, success=None,):
20226 
    self.success = success
20227 
 
20228 
  def read(self, iprot):
20229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20231 
      return
20232 
    iprot.readStructBegin()
20233 
    while True:
20234 
      (fname, ftype, fid) = iprot.readFieldBegin()
20235 
      if ftype == TType.STOP:
20236 
        break
20237 
      if fid == 0:
20238 
        if ftype == TType.LIST:
20239 
          self.success = []
9155 kshitij.so 20240 
          (_etype414, _size411) = iprot.readListBegin()
20241 
          for _i415 in xrange(_size411):
20242 
            _elem416 = Amazonlisted()
20243 
            _elem416.read(iprot)
20244 
            self.success.append(_elem416)
7281 kshitij.so 20245 
          iprot.readListEnd()
20246 
        else:
20247 
          iprot.skip(ftype)
20248 
      else:
20249 
        iprot.skip(ftype)
20250 
      iprot.readFieldEnd()
20251 
    iprot.readStructEnd()
20252 
 
20253 
  def write(self, oprot):
20254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20256 
      return
20257 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
20258 
    if self.success is not None:
20259 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20260 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20261 
      for iter417 in self.success:
20262 
        iter417.write(oprot)
7281 kshitij.so 20263 
      oprot.writeListEnd()
20264 
      oprot.writeFieldEnd()
20265 
    oprot.writeFieldStop()
20266 
    oprot.writeStructEnd()
20267 
 
20268 
  def validate(self):
20269 
    return
20270 
 
20271 
 
20272 
  def __repr__(self):
20273 
    L = ['%s=%r' % (key, value)
20274 
      for key, value in self.__dict__.iteritems()]
20275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20276 
 
20277 
  def __eq__(self, other):
20278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20279 
 
20280 
  def __ne__(self, other):
20281 
    return not (self == other)
20282 
 
8619 kshitij.so 20283 
class searchAmazonItems_args:
20284 
  """
20285 
  Attributes:
20286 
   - searchTerm
20287 
   - offset
20288 
   - limit
20289 
  """
20290 
 
20291 
  thrift_spec = (
20292 
    None, # 0
20293 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20294 
    (2, TType.I64, 'offset', None, None, ), # 2
20295 
    (3, TType.I64, 'limit', None, None, ), # 3
20296 
  )
20297 
 
20298 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
20299 
    self.searchTerm = searchTerm
20300 
    self.offset = offset
20301 
    self.limit = limit
20302 
 
20303 
  def read(self, iprot):
20304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20306 
      return
20307 
    iprot.readStructBegin()
20308 
    while True:
20309 
      (fname, ftype, fid) = iprot.readFieldBegin()
20310 
      if ftype == TType.STOP:
20311 
        break
20312 
      if fid == 1:
20313 
        if ftype == TType.LIST:
20314 
          self.searchTerm = []
9155 kshitij.so 20315 
          (_etype421, _size418) = iprot.readListBegin()
20316 
          for _i422 in xrange(_size418):
20317 
            _elem423 = iprot.readString();
20318 
            self.searchTerm.append(_elem423)
8619 kshitij.so 20319 
          iprot.readListEnd()
20320 
        else:
20321 
          iprot.skip(ftype)
20322 
      elif fid == 2:
20323 
        if ftype == TType.I64:
20324 
          self.offset = iprot.readI64();
20325 
        else:
20326 
          iprot.skip(ftype)
20327 
      elif fid == 3:
20328 
        if ftype == TType.I64:
20329 
          self.limit = iprot.readI64();
20330 
        else:
20331 
          iprot.skip(ftype)
20332 
      else:
20333 
        iprot.skip(ftype)
20334 
      iprot.readFieldEnd()
20335 
    iprot.readStructEnd()
20336 
 
20337 
  def write(self, oprot):
20338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20340 
      return
20341 
    oprot.writeStructBegin('searchAmazonItems_args')
20342 
    if self.searchTerm is not None:
20343 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20344 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20345 
      for iter424 in self.searchTerm:
20346 
        oprot.writeString(iter424)
8619 kshitij.so 20347 
      oprot.writeListEnd()
20348 
      oprot.writeFieldEnd()
20349 
    if self.offset is not None:
20350 
      oprot.writeFieldBegin('offset', TType.I64, 2)
20351 
      oprot.writeI64(self.offset)
20352 
      oprot.writeFieldEnd()
20353 
    if self.limit is not None:
20354 
      oprot.writeFieldBegin('limit', TType.I64, 3)
20355 
      oprot.writeI64(self.limit)
20356 
      oprot.writeFieldEnd()
20357 
    oprot.writeFieldStop()
20358 
    oprot.writeStructEnd()
20359 
 
20360 
  def validate(self):
20361 
    return
20362 
 
20363 
 
20364 
  def __repr__(self):
20365 
    L = ['%s=%r' % (key, value)
20366 
      for key, value in self.__dict__.iteritems()]
20367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20368 
 
20369 
  def __eq__(self, other):
20370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20371 
 
20372 
  def __ne__(self, other):
20373 
    return not (self == other)
20374 
 
20375 
class searchAmazonItems_result:
20376 
  """
20377 
  Attributes:
20378 
   - success
20379 
  """
20380 
 
20381 
  thrift_spec = (
20382 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20383 
  )
20384 
 
20385 
  def __init__(self, success=None,):
20386 
    self.success = success
20387 
 
20388 
  def read(self, iprot):
20389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20391 
      return
20392 
    iprot.readStructBegin()
20393 
    while True:
20394 
      (fname, ftype, fid) = iprot.readFieldBegin()
20395 
      if ftype == TType.STOP:
20396 
        break
20397 
      if fid == 0:
20398 
        if ftype == TType.LIST:
20399 
          self.success = []
9155 kshitij.so 20400 
          (_etype428, _size425) = iprot.readListBegin()
20401 
          for _i429 in xrange(_size425):
20402 
            _elem430 = Amazonlisted()
20403 
            _elem430.read(iprot)
20404 
            self.success.append(_elem430)
8619 kshitij.so 20405 
          iprot.readListEnd()
20406 
        else:
20407 
          iprot.skip(ftype)
20408 
      else:
20409 
        iprot.skip(ftype)
20410 
      iprot.readFieldEnd()
20411 
    iprot.readStructEnd()
20412 
 
20413 
  def write(self, oprot):
20414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20416 
      return
20417 
    oprot.writeStructBegin('searchAmazonItems_result')
20418 
    if self.success is not None:
20419 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20420 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20421 
      for iter431 in self.success:
20422 
        iter431.write(oprot)
8619 kshitij.so 20423 
      oprot.writeListEnd()
20424 
      oprot.writeFieldEnd()
20425 
    oprot.writeFieldStop()
20426 
    oprot.writeStructEnd()
20427 
 
20428 
  def validate(self):
20429 
    return
20430 
 
20431 
 
20432 
  def __repr__(self):
20433 
    L = ['%s=%r' % (key, value)
20434 
      for key, value in self.__dict__.iteritems()]
20435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20436 
 
20437 
  def __eq__(self, other):
20438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20439 
 
20440 
  def __ne__(self, other):
20441 
    return not (self == other)
20442 
 
20443 
class getAmazonSearchResultCount_args:
20444 
  """
20445 
  Attributes:
20446 
   - searchTerm
20447 
  """
20448 
 
20449 
  thrift_spec = (
20450 
    None, # 0
20451 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20452 
  )
20453 
 
20454 
  def __init__(self, searchTerm=None,):
20455 
    self.searchTerm = searchTerm
20456 
 
20457 
  def read(self, iprot):
20458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20460 
      return
20461 
    iprot.readStructBegin()
20462 
    while True:
20463 
      (fname, ftype, fid) = iprot.readFieldBegin()
20464 
      if ftype == TType.STOP:
20465 
        break
20466 
      if fid == 1:
20467 
        if ftype == TType.LIST:
20468 
          self.searchTerm = []
9155 kshitij.so 20469 
          (_etype435, _size432) = iprot.readListBegin()
20470 
          for _i436 in xrange(_size432):
20471 
            _elem437 = iprot.readString();
20472 
            self.searchTerm.append(_elem437)
8619 kshitij.so 20473 
          iprot.readListEnd()
20474 
        else:
20475 
          iprot.skip(ftype)
20476 
      else:
20477 
        iprot.skip(ftype)
20478 
      iprot.readFieldEnd()
20479 
    iprot.readStructEnd()
20480 
 
20481 
  def write(self, oprot):
20482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20484 
      return
20485 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
20486 
    if self.searchTerm is not None:
20487 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20488 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20489 
      for iter438 in self.searchTerm:
20490 
        oprot.writeString(iter438)
8619 kshitij.so 20491 
      oprot.writeListEnd()
20492 
      oprot.writeFieldEnd()
20493 
    oprot.writeFieldStop()
20494 
    oprot.writeStructEnd()
20495 
 
20496 
  def validate(self):
20497 
    return
20498 
 
20499 
 
20500 
  def __repr__(self):
20501 
    L = ['%s=%r' % (key, value)
20502 
      for key, value in self.__dict__.iteritems()]
20503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20504 
 
20505 
  def __eq__(self, other):
20506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20507 
 
20508 
  def __ne__(self, other):
20509 
    return not (self == other)
20510 
 
20511 
class getAmazonSearchResultCount_result:
20512 
  """
20513 
  Attributes:
20514 
   - success
20515 
  """
20516 
 
20517 
  thrift_spec = (
20518 
    (0, TType.I64, 'success', None, None, ), # 0
20519 
  )
20520 
 
20521 
  def __init__(self, success=None,):
20522 
    self.success = success
20523 
 
20524 
  def read(self, iprot):
20525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20527 
      return
20528 
    iprot.readStructBegin()
20529 
    while True:
20530 
      (fname, ftype, fid) = iprot.readFieldBegin()
20531 
      if ftype == TType.STOP:
20532 
        break
20533 
      if fid == 0:
20534 
        if ftype == TType.I64:
20535 
          self.success = iprot.readI64();
20536 
        else:
20537 
          iprot.skip(ftype)
20538 
      else:
20539 
        iprot.skip(ftype)
20540 
      iprot.readFieldEnd()
20541 
    iprot.readStructEnd()
20542 
 
20543 
  def write(self, oprot):
20544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20546 
      return
20547 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
20548 
    if self.success is not None:
20549 
      oprot.writeFieldBegin('success', TType.I64, 0)
20550 
      oprot.writeI64(self.success)
20551 
      oprot.writeFieldEnd()
20552 
    oprot.writeFieldStop()
20553 
    oprot.writeStructEnd()
20554 
 
20555 
  def validate(self):
20556 
    return
20557 
 
20558 
 
20559 
  def __repr__(self):
20560 
    L = ['%s=%r' % (key, value)
20561 
      for key, value in self.__dict__.iteritems()]
20562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20563 
 
20564 
  def __eq__(self, other):
20565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20566 
 
20567 
  def __ne__(self, other):
20568 
    return not (self == other)
20569 
 
20570 
class getCountForAmazonlistedItems_args:
20571 
 
20572 
  thrift_spec = (
20573 
  )
20574 
 
20575 
  def read(self, iprot):
20576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20578 
      return
20579 
    iprot.readStructBegin()
20580 
    while True:
20581 
      (fname, ftype, fid) = iprot.readFieldBegin()
20582 
      if ftype == TType.STOP:
20583 
        break
20584 
      else:
20585 
        iprot.skip(ftype)
20586 
      iprot.readFieldEnd()
20587 
    iprot.readStructEnd()
20588 
 
20589 
  def write(self, oprot):
20590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20592 
      return
20593 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
20594 
    oprot.writeFieldStop()
20595 
    oprot.writeStructEnd()
20596 
 
20597 
  def validate(self):
20598 
    return
20599 
 
20600 
 
20601 
  def __repr__(self):
20602 
    L = ['%s=%r' % (key, value)
20603 
      for key, value in self.__dict__.iteritems()]
20604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20605 
 
20606 
  def __eq__(self, other):
20607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20608 
 
20609 
  def __ne__(self, other):
20610 
    return not (self == other)
20611 
 
20612 
class getCountForAmazonlistedItems_result:
20613 
  """
20614 
  Attributes:
20615 
   - success
20616 
  """
20617 
 
20618 
  thrift_spec = (
20619 
    (0, TType.I64, 'success', None, None, ), # 0
20620 
  )
20621 
 
20622 
  def __init__(self, success=None,):
20623 
    self.success = success
20624 
 
20625 
  def read(self, iprot):
20626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20628 
      return
20629 
    iprot.readStructBegin()
20630 
    while True:
20631 
      (fname, ftype, fid) = iprot.readFieldBegin()
20632 
      if ftype == TType.STOP:
20633 
        break
20634 
      if fid == 0:
20635 
        if ftype == TType.I64:
20636 
          self.success = iprot.readI64();
20637 
        else:
20638 
          iprot.skip(ftype)
20639 
      else:
20640 
        iprot.skip(ftype)
20641 
      iprot.readFieldEnd()
20642 
    iprot.readStructEnd()
20643 
 
20644 
  def write(self, oprot):
20645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20647 
      return
20648 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
20649 
    if self.success is not None:
20650 
      oprot.writeFieldBegin('success', TType.I64, 0)
20651 
      oprot.writeI64(self.success)
20652 
      oprot.writeFieldEnd()
20653 
    oprot.writeFieldStop()
20654 
    oprot.writeStructEnd()
20655 
 
20656 
  def validate(self):
20657 
    return
20658 
 
20659 
 
20660 
  def __repr__(self):
20661 
    L = ['%s=%r' % (key, value)
20662 
      for key, value in self.__dict__.iteritems()]
20663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20664 
 
20665 
  def __eq__(self, other):
20666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20667 
 
20668 
  def __ne__(self, other):
20669 
    return not (self == other)
20670 
 
7281 kshitij.so 20671 
class getAmazonItemDetails_args:
20672 
  """
20673 
  Attributes:
20674 
   - itemId
20675 
  """
20676 
 
20677 
  thrift_spec = (
20678 
    None, # 0
20679 
    (1, TType.I64, 'itemId', None, None, ), # 1
20680 
  )
20681 
 
20682 
  def __init__(self, itemId=None,):
20683 
    self.itemId = itemId
20684 
 
20685 
  def read(self, iprot):
20686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20688 
      return
20689 
    iprot.readStructBegin()
20690 
    while True:
20691 
      (fname, ftype, fid) = iprot.readFieldBegin()
20692 
      if ftype == TType.STOP:
20693 
        break
20694 
      if fid == 1:
20695 
        if ftype == TType.I64:
20696 
          self.itemId = iprot.readI64();
20697 
        else:
20698 
          iprot.skip(ftype)
20699 
      else:
20700 
        iprot.skip(ftype)
20701 
      iprot.readFieldEnd()
20702 
    iprot.readStructEnd()
20703 
 
20704 
  def write(self, oprot):
20705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20707 
      return
20708 
    oprot.writeStructBegin('getAmazonItemDetails_args')
20709 
    if self.itemId is not None:
20710 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20711 
      oprot.writeI64(self.itemId)
20712 
      oprot.writeFieldEnd()
20713 
    oprot.writeFieldStop()
20714 
    oprot.writeStructEnd()
20715 
 
20716 
  def validate(self):
20717 
    return
20718 
 
20719 
 
20720 
  def __repr__(self):
20721 
    L = ['%s=%r' % (key, value)
20722 
      for key, value in self.__dict__.iteritems()]
20723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20724 
 
20725 
  def __eq__(self, other):
20726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20727 
 
20728 
  def __ne__(self, other):
20729 
    return not (self == other)
20730 
 
20731 
class getAmazonItemDetails_result:
20732 
  """
20733 
  Attributes:
20734 
   - success
20735 
  """
20736 
 
20737 
  thrift_spec = (
20738 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
20739 
  )
20740 
 
20741 
  def __init__(self, success=None,):
20742 
    self.success = success
20743 
 
20744 
  def read(self, iprot):
20745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20747 
      return
20748 
    iprot.readStructBegin()
20749 
    while True:
20750 
      (fname, ftype, fid) = iprot.readFieldBegin()
20751 
      if ftype == TType.STOP:
20752 
        break
20753 
      if fid == 0:
20754 
        if ftype == TType.STRUCT:
20755 
          self.success = Amazonlisted()
20756 
          self.success.read(iprot)
20757 
        else:
20758 
          iprot.skip(ftype)
20759 
      else:
20760 
        iprot.skip(ftype)
20761 
      iprot.readFieldEnd()
20762 
    iprot.readStructEnd()
20763 
 
20764 
  def write(self, oprot):
20765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20767 
      return
20768 
    oprot.writeStructBegin('getAmazonItemDetails_result')
20769 
    if self.success is not None:
20770 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20771 
      self.success.write(oprot)
20772 
      oprot.writeFieldEnd()
20773 
    oprot.writeFieldStop()
20774 
    oprot.writeStructEnd()
20775 
 
20776 
  def validate(self):
20777 
    return
20778 
 
20779 
 
20780 
  def __repr__(self):
20781 
    L = ['%s=%r' % (key, value)
20782 
      for key, value in self.__dict__.iteritems()]
20783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20784 
 
20785 
  def __eq__(self, other):
20786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20787 
 
20788 
  def __ne__(self, other):
20789 
    return not (self == other)
20790 
 
20791 
class updateAmazonItemDetails_args:
20792 
  """
20793 
  Attributes:
8168 kshitij.so 20794 
   - amazonlisted
7281 kshitij.so 20795 
  """
20796 
 
20797 
  thrift_spec = (
20798 
    None, # 0
8168 kshitij.so 20799 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 20800 
  )
20801 
 
8168 kshitij.so 20802 
  def __init__(self, amazonlisted=None,):
20803 
    self.amazonlisted = amazonlisted
7281 kshitij.so 20804 
 
20805 
  def read(self, iprot):
20806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20808 
      return
20809 
    iprot.readStructBegin()
20810 
    while True:
20811 
      (fname, ftype, fid) = iprot.readFieldBegin()
20812 
      if ftype == TType.STOP:
20813 
        break
20814 
      if fid == 1:
8168 kshitij.so 20815 
        if ftype == TType.STRUCT:
20816 
          self.amazonlisted = Amazonlisted()
20817 
          self.amazonlisted.read(iprot)
7281 kshitij.so 20818 
        else:
20819 
          iprot.skip(ftype)
20820 
      else:
20821 
        iprot.skip(ftype)
20822 
      iprot.readFieldEnd()
20823 
    iprot.readStructEnd()
20824 
 
20825 
  def write(self, oprot):
20826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20828 
      return
20829 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 20830 
    if self.amazonlisted is not None:
20831 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20832 
      self.amazonlisted.write(oprot)
7281 kshitij.so 20833 
      oprot.writeFieldEnd()
20834 
    oprot.writeFieldStop()
20835 
    oprot.writeStructEnd()
20836 
 
20837 
  def validate(self):
20838 
    return
20839 
 
20840 
 
20841 
  def __repr__(self):
20842 
    L = ['%s=%r' % (key, value)
20843 
      for key, value in self.__dict__.iteritems()]
20844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20845 
 
20846 
  def __eq__(self, other):
20847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20848 
 
20849 
  def __ne__(self, other):
20850 
    return not (self == other)
20851 
 
20852 
class updateAmazonItemDetails_result:
20853 
 
20854 
  thrift_spec = (
20855 
  )
20856 
 
20857 
  def read(self, iprot):
20858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20860 
      return
20861 
    iprot.readStructBegin()
20862 
    while True:
20863 
      (fname, ftype, fid) = iprot.readFieldBegin()
20864 
      if ftype == TType.STOP:
20865 
        break
20866 
      else:
20867 
        iprot.skip(ftype)
20868 
      iprot.readFieldEnd()
20869 
    iprot.readStructEnd()
20870 
 
20871 
  def write(self, oprot):
20872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20874 
      return
20875 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
20876 
    oprot.writeFieldStop()
20877 
    oprot.writeStructEnd()
20878 
 
20879 
  def validate(self):
20880 
    return
20881 
 
20882 
 
20883 
  def __repr__(self):
20884 
    L = ['%s=%r' % (key, value)
20885 
      for key, value in self.__dict__.iteritems()]
20886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20887 
 
20888 
  def __eq__(self, other):
20889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20890 
 
20891 
  def __ne__(self, other):
20892 
    return not (self == other)
20893 
 
20894 
class addAmazonItem_args:
20895 
  """
20896 
  Attributes:
20897 
   - amazonlisted
20898 
  """
20899 
 
20900 
  thrift_spec = (
20901 
    None, # 0
20902 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
20903 
  )
20904 
 
20905 
  def __init__(self, amazonlisted=None,):
20906 
    self.amazonlisted = amazonlisted
20907 
 
20908 
  def read(self, iprot):
20909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20911 
      return
20912 
    iprot.readStructBegin()
20913 
    while True:
20914 
      (fname, ftype, fid) = iprot.readFieldBegin()
20915 
      if ftype == TType.STOP:
20916 
        break
20917 
      if fid == 1:
20918 
        if ftype == TType.STRUCT:
20919 
          self.amazonlisted = Amazonlisted()
20920 
          self.amazonlisted.read(iprot)
20921 
        else:
20922 
          iprot.skip(ftype)
20923 
      else:
20924 
        iprot.skip(ftype)
20925 
      iprot.readFieldEnd()
20926 
    iprot.readStructEnd()
20927 
 
20928 
  def write(self, oprot):
20929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20931 
      return
20932 
    oprot.writeStructBegin('addAmazonItem_args')
20933 
    if self.amazonlisted is not None:
20934 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20935 
      self.amazonlisted.write(oprot)
20936 
      oprot.writeFieldEnd()
20937 
    oprot.writeFieldStop()
20938 
    oprot.writeStructEnd()
20939 
 
20940 
  def validate(self):
20941 
    return
20942 
 
20943 
 
20944 
  def __repr__(self):
20945 
    L = ['%s=%r' % (key, value)
20946 
      for key, value in self.__dict__.iteritems()]
20947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20948 
 
20949 
  def __eq__(self, other):
20950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20951 
 
20952 
  def __ne__(self, other):
20953 
    return not (self == other)
20954 
 
20955 
class addAmazonItem_result:
20956 
 
20957 
  thrift_spec = (
20958 
  )
20959 
 
20960 
  def read(self, iprot):
20961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20963 
      return
20964 
    iprot.readStructBegin()
20965 
    while True:
20966 
      (fname, ftype, fid) = iprot.readFieldBegin()
20967 
      if ftype == TType.STOP:
20968 
        break
20969 
      else:
20970 
        iprot.skip(ftype)
20971 
      iprot.readFieldEnd()
20972 
    iprot.readStructEnd()
20973 
 
20974 
  def write(self, oprot):
20975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20977 
      return
20978 
    oprot.writeStructBegin('addAmazonItem_result')
20979 
    oprot.writeFieldStop()
20980 
    oprot.writeStructEnd()
20981 
 
20982 
  def validate(self):
20983 
    return
20984 
 
20985 
 
20986 
  def __repr__(self):
20987 
    L = ['%s=%r' % (key, value)
20988 
      for key, value in self.__dict__.iteritems()]
20989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20990 
 
20991 
  def __eq__(self, other):
20992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20993 
 
20994 
  def __ne__(self, other):
20995 
    return not (self == other)
7291 vikram.rag 20996 
 
20997 
class getAsinItems_args:
20998 
 
20999 
  thrift_spec = (
21000 
  )
21001 
 
21002 
  def read(self, iprot):
21003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21005 
      return
21006 
    iprot.readStructBegin()
21007 
    while True:
21008 
      (fname, ftype, fid) = iprot.readFieldBegin()
21009 
      if ftype == TType.STOP:
21010 
        break
21011 
      else:
21012 
        iprot.skip(ftype)
21013 
      iprot.readFieldEnd()
21014 
    iprot.readStructEnd()
21015 
 
21016 
  def write(self, oprot):
21017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21019 
      return
21020 
    oprot.writeStructBegin('getAsinItems_args')
21021 
    oprot.writeFieldStop()
21022 
    oprot.writeStructEnd()
21023 
 
21024 
  def validate(self):
21025 
    return
21026 
 
21027 
 
21028 
  def __repr__(self):
21029 
    L = ['%s=%r' % (key, value)
21030 
      for key, value in self.__dict__.iteritems()]
21031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21032 
 
21033 
  def __eq__(self, other):
21034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21035 
 
21036 
  def __ne__(self, other):
21037 
    return not (self == other)
21038 
 
21039 
class getAsinItems_result:
21040 
  """
21041 
  Attributes:
21042 
   - success
21043 
  """
21044 
 
21045 
  thrift_spec = (
21046 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21047 
  )
21048 
 
21049 
  def __init__(self, success=None,):
21050 
    self.success = success
21051 
 
21052 
  def read(self, iprot):
21053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21055 
      return
21056 
    iprot.readStructBegin()
21057 
    while True:
21058 
      (fname, ftype, fid) = iprot.readFieldBegin()
21059 
      if ftype == TType.STOP:
21060 
        break
21061 
      if fid == 0:
21062 
        if ftype == TType.LIST:
21063 
          self.success = []
9155 kshitij.so 21064 
          (_etype442, _size439) = iprot.readListBegin()
21065 
          for _i443 in xrange(_size439):
21066 
            _elem444 = Item()
21067 
            _elem444.read(iprot)
21068 
            self.success.append(_elem444)
7291 vikram.rag 21069 
          iprot.readListEnd()
21070 
        else:
21071 
          iprot.skip(ftype)
21072 
      else:
21073 
        iprot.skip(ftype)
21074 
      iprot.readFieldEnd()
21075 
    iprot.readStructEnd()
21076 
 
21077 
  def write(self, oprot):
21078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21080 
      return
21081 
    oprot.writeStructBegin('getAsinItems_result')
21082 
    if self.success is not None:
21083 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21084 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21085 
      for iter445 in self.success:
21086 
        iter445.write(oprot)
7291 vikram.rag 21087 
      oprot.writeListEnd()
21088 
      oprot.writeFieldEnd()
21089 
    oprot.writeFieldStop()
21090 
    oprot.writeStructEnd()
21091 
 
21092 
  def validate(self):
21093 
    return
21094 
 
21095 
 
21096 
  def __repr__(self):
21097 
    L = ['%s=%r' % (key, value)
21098 
      for key, value in self.__dict__.iteritems()]
21099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21100 
 
21101 
  def __eq__(self, other):
21102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21103 
 
21104 
  def __ne__(self, other):
21105 
    return not (self == other)
21106 
 
21107 
class getAllFbaListedItems_args:
21108 
 
21109 
  thrift_spec = (
21110 
  )
21111 
 
21112 
  def read(self, iprot):
21113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21115 
      return
21116 
    iprot.readStructBegin()
21117 
    while True:
21118 
      (fname, ftype, fid) = iprot.readFieldBegin()
21119 
      if ftype == TType.STOP:
21120 
        break
21121 
      else:
21122 
        iprot.skip(ftype)
21123 
      iprot.readFieldEnd()
21124 
    iprot.readStructEnd()
21125 
 
21126 
  def write(self, oprot):
21127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21129 
      return
21130 
    oprot.writeStructBegin('getAllFbaListedItems_args')
21131 
    oprot.writeFieldStop()
21132 
    oprot.writeStructEnd()
21133 
 
21134 
  def validate(self):
21135 
    return
21136 
 
21137 
 
21138 
  def __repr__(self):
21139 
    L = ['%s=%r' % (key, value)
21140 
      for key, value in self.__dict__.iteritems()]
21141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21142 
 
21143 
  def __eq__(self, other):
21144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21145 
 
21146 
  def __ne__(self, other):
21147 
    return not (self == other)
21148 
 
21149 
class getAllFbaListedItems_result:
21150 
  """
21151 
  Attributes:
21152 
   - success
21153 
  """
21154 
 
21155 
  thrift_spec = (
21156 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21157 
  )
21158 
 
21159 
  def __init__(self, success=None,):
21160 
    self.success = success
21161 
 
21162 
  def read(self, iprot):
21163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21165 
      return
21166 
    iprot.readStructBegin()
21167 
    while True:
21168 
      (fname, ftype, fid) = iprot.readFieldBegin()
21169 
      if ftype == TType.STOP:
21170 
        break
21171 
      if fid == 0:
21172 
        if ftype == TType.LIST:
21173 
          self.success = []
9155 kshitij.so 21174 
          (_etype449, _size446) = iprot.readListBegin()
21175 
          for _i450 in xrange(_size446):
21176 
            _elem451 = Amazonlisted()
21177 
            _elem451.read(iprot)
21178 
            self.success.append(_elem451)
7291 vikram.rag 21179 
          iprot.readListEnd()
21180 
        else:
21181 
          iprot.skip(ftype)
21182 
      else:
21183 
        iprot.skip(ftype)
21184 
      iprot.readFieldEnd()
21185 
    iprot.readStructEnd()
21186 
 
21187 
  def write(self, oprot):
21188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21190 
      return
21191 
    oprot.writeStructBegin('getAllFbaListedItems_result')
21192 
    if self.success is not None:
21193 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21194 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21195 
      for iter452 in self.success:
21196 
        iter452.write(oprot)
7291 vikram.rag 21197 
      oprot.writeListEnd()
21198 
      oprot.writeFieldEnd()
21199 
    oprot.writeFieldStop()
21200 
    oprot.writeStructEnd()
21201 
 
21202 
  def validate(self):
21203 
    return
21204 
 
21205 
 
21206 
  def __repr__(self):
21207 
    L = ['%s=%r' % (key, value)
21208 
      for key, value in self.__dict__.iteritems()]
21209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21210 
 
21211 
  def __eq__(self, other):
21212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21213 
 
21214 
  def __ne__(self, other):
21215 
    return not (self == other)
21216 
 
21217 
class getAllNonFbaListedItems_args:
21218 
 
21219 
  thrift_spec = (
21220 
  )
21221 
 
21222 
  def read(self, iprot):
21223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21225 
      return
21226 
    iprot.readStructBegin()
21227 
    while True:
21228 
      (fname, ftype, fid) = iprot.readFieldBegin()
21229 
      if ftype == TType.STOP:
21230 
        break
21231 
      else:
21232 
        iprot.skip(ftype)
21233 
      iprot.readFieldEnd()
21234 
    iprot.readStructEnd()
21235 
 
21236 
  def write(self, oprot):
21237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21239 
      return
21240 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
21241 
    oprot.writeFieldStop()
21242 
    oprot.writeStructEnd()
21243 
 
21244 
  def validate(self):
21245 
    return
21246 
 
21247 
 
21248 
  def __repr__(self):
21249 
    L = ['%s=%r' % (key, value)
21250 
      for key, value in self.__dict__.iteritems()]
21251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21252 
 
21253 
  def __eq__(self, other):
21254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21255 
 
21256 
  def __ne__(self, other):
21257 
    return not (self == other)
21258 
 
21259 
class getAllNonFbaListedItems_result:
21260 
  """
21261 
  Attributes:
21262 
   - success
21263 
  """
21264 
 
21265 
  thrift_spec = (
21266 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21267 
  )
21268 
 
21269 
  def __init__(self, success=None,):
21270 
    self.success = success
21271 
 
21272 
  def read(self, iprot):
21273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21275 
      return
21276 
    iprot.readStructBegin()
21277 
    while True:
21278 
      (fname, ftype, fid) = iprot.readFieldBegin()
21279 
      if ftype == TType.STOP:
21280 
        break
21281 
      if fid == 0:
21282 
        if ftype == TType.LIST:
21283 
          self.success = []
9155 kshitij.so 21284 
          (_etype456, _size453) = iprot.readListBegin()
21285 
          for _i457 in xrange(_size453):
21286 
            _elem458 = Amazonlisted()
21287 
            _elem458.read(iprot)
21288 
            self.success.append(_elem458)
7291 vikram.rag 21289 
          iprot.readListEnd()
21290 
        else:
21291 
          iprot.skip(ftype)
21292 
      else:
21293 
        iprot.skip(ftype)
21294 
      iprot.readFieldEnd()
21295 
    iprot.readStructEnd()
21296 
 
21297 
  def write(self, oprot):
21298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21300 
      return
21301 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
21302 
    if self.success is not None:
21303 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21304 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21305 
      for iter459 in self.success:
21306 
        iter459.write(oprot)
7291 vikram.rag 21307 
      oprot.writeListEnd()
21308 
      oprot.writeFieldEnd()
21309 
    oprot.writeFieldStop()
21310 
    oprot.writeStructEnd()
21311 
 
21312 
  def validate(self):
21313 
    return
21314 
 
21315 
 
21316 
  def __repr__(self):
21317 
    L = ['%s=%r' % (key, value)
21318 
      for key, value in self.__dict__.iteritems()]
21319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21320 
 
21321 
  def __eq__(self, other):
21322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21323 
 
21324 
  def __ne__(self, other):
21325 
    return not (self == other)
7460 kshitij.so 21326 
 
21327 
class updateItemInventory_args:
21328 
  """
21329 
  Attributes:
21330 
   - itemId
21331 
   - holdInventory
21332 
   - defaultInventory
21333 
  """
21334 
 
21335 
  thrift_spec = (
21336 
    None, # 0
21337 
    (1, TType.I64, 'itemId', None, None, ), # 1
21338 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
21339 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
21340 
  )
21341 
 
21342 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
21343 
    self.itemId = itemId
21344 
    self.holdInventory = holdInventory
21345 
    self.defaultInventory = defaultInventory
21346 
 
21347 
  def read(self, iprot):
21348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21350 
      return
21351 
    iprot.readStructBegin()
21352 
    while True:
21353 
      (fname, ftype, fid) = iprot.readFieldBegin()
21354 
      if ftype == TType.STOP:
21355 
        break
21356 
      if fid == 1:
21357 
        if ftype == TType.I64:
21358 
          self.itemId = iprot.readI64();
21359 
        else:
21360 
          iprot.skip(ftype)
21361 
      elif fid == 2:
21362 
        if ftype == TType.I64:
21363 
          self.holdInventory = iprot.readI64();
21364 
        else:
21365 
          iprot.skip(ftype)
21366 
      elif fid == 3:
21367 
        if ftype == TType.I64:
21368 
          self.defaultInventory = iprot.readI64();
21369 
        else:
21370 
          iprot.skip(ftype)
21371 
      else:
21372 
        iprot.skip(ftype)
21373 
      iprot.readFieldEnd()
21374 
    iprot.readStructEnd()
21375 
 
21376 
  def write(self, oprot):
21377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21379 
      return
21380 
    oprot.writeStructBegin('updateItemInventory_args')
21381 
    if self.itemId is not None:
21382 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21383 
      oprot.writeI64(self.itemId)
21384 
      oprot.writeFieldEnd()
21385 
    if self.holdInventory is not None:
21386 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
21387 
      oprot.writeI64(self.holdInventory)
21388 
      oprot.writeFieldEnd()
21389 
    if self.defaultInventory is not None:
21390 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
21391 
      oprot.writeI64(self.defaultInventory)
21392 
      oprot.writeFieldEnd()
21393 
    oprot.writeFieldStop()
21394 
    oprot.writeStructEnd()
21395 
 
21396 
  def validate(self):
21397 
    return
21398 
 
21399 
 
21400 
  def __repr__(self):
21401 
    L = ['%s=%r' % (key, value)
21402 
      for key, value in self.__dict__.iteritems()]
21403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21404 
 
21405 
  def __eq__(self, other):
21406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21407 
 
21408 
  def __ne__(self, other):
21409 
    return not (self == other)
21410 
 
21411 
class updateItemInventory_result:
21412 
  """
21413 
  Attributes:
21414 
   - success
21415 
  """
21416 
 
21417 
  thrift_spec = (
21418 
    (0, TType.BOOL, 'success', None, None, ), # 0
21419 
  )
21420 
 
21421 
  def __init__(self, success=None,):
21422 
    self.success = success
21423 
 
21424 
  def read(self, iprot):
21425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21427 
      return
21428 
    iprot.readStructBegin()
21429 
    while True:
21430 
      (fname, ftype, fid) = iprot.readFieldBegin()
21431 
      if ftype == TType.STOP:
21432 
        break
21433 
      if fid == 0:
21434 
        if ftype == TType.BOOL:
21435 
          self.success = iprot.readBool();
21436 
        else:
21437 
          iprot.skip(ftype)
21438 
      else:
21439 
        iprot.skip(ftype)
21440 
      iprot.readFieldEnd()
21441 
    iprot.readStructEnd()
21442 
 
21443 
  def write(self, oprot):
21444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21446 
      return
21447 
    oprot.writeStructBegin('updateItemInventory_result')
21448 
    if self.success is not None:
21449 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21450 
      oprot.writeBool(self.success)
21451 
      oprot.writeFieldEnd()
21452 
    oprot.writeFieldStop()
21453 
    oprot.writeStructEnd()
21454 
 
21455 
  def validate(self):
21456 
    return
21457 
 
21458 
 
21459 
  def __repr__(self):
21460 
    L = ['%s=%r' % (key, value)
21461 
      for key, value in self.__dict__.iteritems()]
21462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21463 
 
21464 
  def __eq__(self, other):
21465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21466 
 
21467 
  def __ne__(self, other):
21468 
    return not (self == other)
7770 kshitij.so 21469 
 
21470 
class updateTimestampForAmazonFeeds_args:
21471 
  """
21472 
  Attributes:
21473 
   - type
21474 
   - sku
21475 
   - timestamp
21476 
  """
21477 
 
21478 
  thrift_spec = (
21479 
    None, # 0
21480 
    (1, TType.STRING, 'type', None, None, ), # 1
21481 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
21482 
    (3, TType.I64, 'timestamp', None, None, ), # 3
21483 
  )
21484 
 
21485 
  def __init__(self, type=None, sku=None, timestamp=None,):
21486 
    self.type = type
21487 
    self.sku = sku
21488 
    self.timestamp = timestamp
21489 
 
21490 
  def read(self, iprot):
21491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21493 
      return
21494 
    iprot.readStructBegin()
21495 
    while True:
21496 
      (fname, ftype, fid) = iprot.readFieldBegin()
21497 
      if ftype == TType.STOP:
21498 
        break
21499 
      if fid == 1:
21500 
        if ftype == TType.STRING:
21501 
          self.type = iprot.readString();
21502 
        else:
21503 
          iprot.skip(ftype)
21504 
      elif fid == 2:
21505 
        if ftype == TType.LIST:
21506 
          self.sku = []
9155 kshitij.so 21507 
          (_etype463, _size460) = iprot.readListBegin()
21508 
          for _i464 in xrange(_size460):
21509 
            _elem465 = iprot.readI64();
21510 
            self.sku.append(_elem465)
7770 kshitij.so 21511 
          iprot.readListEnd()
21512 
        else:
21513 
          iprot.skip(ftype)
21514 
      elif fid == 3:
21515 
        if ftype == TType.I64:
21516 
          self.timestamp = iprot.readI64();
21517 
        else:
21518 
          iprot.skip(ftype)
21519 
      else:
21520 
        iprot.skip(ftype)
21521 
      iprot.readFieldEnd()
21522 
    iprot.readStructEnd()
21523 
 
21524 
  def write(self, oprot):
21525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21527 
      return
21528 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
21529 
    if self.type is not None:
21530 
      oprot.writeFieldBegin('type', TType.STRING, 1)
21531 
      oprot.writeString(self.type)
21532 
      oprot.writeFieldEnd()
21533 
    if self.sku is not None:
21534 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
21535 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 21536 
      for iter466 in self.sku:
21537 
        oprot.writeI64(iter466)
7770 kshitij.so 21538 
      oprot.writeListEnd()
21539 
      oprot.writeFieldEnd()
21540 
    if self.timestamp is not None:
21541 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
21542 
      oprot.writeI64(self.timestamp)
21543 
      oprot.writeFieldEnd()
21544 
    oprot.writeFieldStop()
21545 
    oprot.writeStructEnd()
21546 
 
21547 
  def validate(self):
21548 
    return
21549 
 
21550 
 
21551 
  def __repr__(self):
21552 
    L = ['%s=%r' % (key, value)
21553 
      for key, value in self.__dict__.iteritems()]
21554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21555 
 
21556 
  def __eq__(self, other):
21557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21558 
 
21559 
  def __ne__(self, other):
21560 
    return not (self == other)
21561 
 
21562 
class updateTimestampForAmazonFeeds_result:
21563 
  """
21564 
  Attributes:
21565 
   - success
21566 
  """
21567 
 
21568 
  thrift_spec = (
21569 
    (0, TType.BOOL, 'success', None, None, ), # 0
21570 
  )
21571 
 
21572 
  def __init__(self, success=None,):
21573 
    self.success = success
21574 
 
21575 
  def read(self, iprot):
21576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21578 
      return
21579 
    iprot.readStructBegin()
21580 
    while True:
21581 
      (fname, ftype, fid) = iprot.readFieldBegin()
21582 
      if ftype == TType.STOP:
21583 
        break
21584 
      if fid == 0:
21585 
        if ftype == TType.BOOL:
21586 
          self.success = iprot.readBool();
21587 
        else:
21588 
          iprot.skip(ftype)
21589 
      else:
21590 
        iprot.skip(ftype)
21591 
      iprot.readFieldEnd()
21592 
    iprot.readStructEnd()
21593 
 
21594 
  def write(self, oprot):
21595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21597 
      return
21598 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
21599 
    if self.success is not None:
21600 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21601 
      oprot.writeBool(self.success)
21602 
      oprot.writeFieldEnd()
21603 
    oprot.writeFieldStop()
21604 
    oprot.writeStructEnd()
21605 
 
21606 
  def validate(self):
21607 
    return
21608 
 
21609 
 
21610 
  def __repr__(self):
21611 
    L = ['%s=%r' % (key, value)
21612 
      for key, value in self.__dict__.iteritems()]
21613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21614 
 
21615 
  def __eq__(self, other):
21616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21617 
 
21618 
  def __ne__(self, other):
21619 
    return not (self == other)
7897 amar.kumar 21620 
 
21621 
class getAllParentCategories_args:
21622 
 
21623 
  thrift_spec = (
21624 
  )
21625 
 
21626 
  def read(self, iprot):
21627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21629 
      return
21630 
    iprot.readStructBegin()
21631 
    while True:
21632 
      (fname, ftype, fid) = iprot.readFieldBegin()
21633 
      if ftype == TType.STOP:
21634 
        break
21635 
      else:
21636 
        iprot.skip(ftype)
21637 
      iprot.readFieldEnd()
21638 
    iprot.readStructEnd()
21639 
 
21640 
  def write(self, oprot):
21641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21643 
      return
21644 
    oprot.writeStructBegin('getAllParentCategories_args')
21645 
    oprot.writeFieldStop()
21646 
    oprot.writeStructEnd()
21647 
 
21648 
  def validate(self):
21649 
    return
21650 
 
21651 
 
21652 
  def __repr__(self):
21653 
    L = ['%s=%r' % (key, value)
21654 
      for key, value in self.__dict__.iteritems()]
21655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21656 
 
21657 
  def __eq__(self, other):
21658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21659 
 
21660 
  def __ne__(self, other):
21661 
    return not (self == other)
21662 
 
21663 
class getAllParentCategories_result:
21664 
  """
21665 
  Attributes:
21666 
   - success
21667 
  """
21668 
 
21669 
  thrift_spec = (
21670 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
21671 
  )
21672 
 
21673 
  def __init__(self, success=None,):
21674 
    self.success = success
21675 
 
21676 
  def read(self, iprot):
21677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21679 
      return
21680 
    iprot.readStructBegin()
21681 
    while True:
21682 
      (fname, ftype, fid) = iprot.readFieldBegin()
21683 
      if ftype == TType.STOP:
21684 
        break
21685 
      if fid == 0:
21686 
        if ftype == TType.LIST:
21687 
          self.success = []
9155 kshitij.so 21688 
          (_etype470, _size467) = iprot.readListBegin()
21689 
          for _i471 in xrange(_size467):
21690 
            _elem472 = Category()
21691 
            _elem472.read(iprot)
21692 
            self.success.append(_elem472)
7897 amar.kumar 21693 
          iprot.readListEnd()
21694 
        else:
21695 
          iprot.skip(ftype)
21696 
      else:
21697 
        iprot.skip(ftype)
21698 
      iprot.readFieldEnd()
21699 
    iprot.readStructEnd()
21700 
 
21701 
  def write(self, oprot):
21702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21704 
      return
21705 
    oprot.writeStructBegin('getAllParentCategories_result')
21706 
    if self.success is not None:
21707 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21708 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21709 
      for iter473 in self.success:
21710 
        iter473.write(oprot)
7897 amar.kumar 21711 
      oprot.writeListEnd()
21712 
      oprot.writeFieldEnd()
21713 
    oprot.writeFieldStop()
21714 
    oprot.writeStructEnd()
21715 
 
21716 
  def validate(self):
21717 
    return
21718 
 
21719 
 
21720 
  def __repr__(self):
21721 
    L = ['%s=%r' % (key, value)
21722 
      for key, value in self.__dict__.iteritems()]
21723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21724 
 
21725 
  def __eq__(self, other):
21726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21727 
 
21728 
  def __ne__(self, other):
21729 
    return not (self == other)
7977 kshitij.so 21730 
 
21731 
class addPageViewEvent_args:
21732 
  """
21733 
  Attributes:
21734 
   - pageViewEvents
21735 
  """
21736 
 
21737 
  thrift_spec = (
21738 
    None, # 0
21739 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
21740 
  )
21741 
 
21742 
  def __init__(self, pageViewEvents=None,):
21743 
    self.pageViewEvents = pageViewEvents
21744 
 
21745 
  def read(self, iprot):
21746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21748 
      return
21749 
    iprot.readStructBegin()
21750 
    while True:
21751 
      (fname, ftype, fid) = iprot.readFieldBegin()
21752 
      if ftype == TType.STOP:
21753 
        break
21754 
      if fid == 1:
21755 
        if ftype == TType.STRUCT:
21756 
          self.pageViewEvents = PageViewEvents()
21757 
          self.pageViewEvents.read(iprot)
21758 
        else:
21759 
          iprot.skip(ftype)
21760 
      else:
21761 
        iprot.skip(ftype)
21762 
      iprot.readFieldEnd()
21763 
    iprot.readStructEnd()
21764 
 
21765 
  def write(self, oprot):
21766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21768 
      return
21769 
    oprot.writeStructBegin('addPageViewEvent_args')
21770 
    if self.pageViewEvents is not None:
21771 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
21772 
      self.pageViewEvents.write(oprot)
21773 
      oprot.writeFieldEnd()
21774 
    oprot.writeFieldStop()
21775 
    oprot.writeStructEnd()
21776 
 
21777 
  def validate(self):
21778 
    return
21779 
 
21780 
 
21781 
  def __repr__(self):
21782 
    L = ['%s=%r' % (key, value)
21783 
      for key, value in self.__dict__.iteritems()]
21784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21785 
 
21786 
  def __eq__(self, other):
21787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21788 
 
21789 
  def __ne__(self, other):
21790 
    return not (self == other)
21791 
 
21792 
class addPageViewEvent_result:
21793 
 
21794 
  thrift_spec = (
21795 
  )
21796 
 
21797 
  def read(self, iprot):
21798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21800 
      return
21801 
    iprot.readStructBegin()
21802 
    while True:
21803 
      (fname, ftype, fid) = iprot.readFieldBegin()
21804 
      if ftype == TType.STOP:
21805 
        break
21806 
      else:
21807 
        iprot.skip(ftype)
21808 
      iprot.readFieldEnd()
21809 
    iprot.readStructEnd()
21810 
 
21811 
  def write(self, oprot):
21812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21814 
      return
21815 
    oprot.writeStructBegin('addPageViewEvent_result')
21816 
    oprot.writeFieldStop()
21817 
    oprot.writeStructEnd()
21818 
 
21819 
  def validate(self):
21820 
    return
21821 
 
21822 
 
21823 
  def __repr__(self):
21824 
    L = ['%s=%r' % (key, value)
21825 
      for key, value in self.__dict__.iteritems()]
21826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21827 
 
21828 
  def __eq__(self, other):
21829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21830 
 
21831 
  def __ne__(self, other):
21832 
    return not (self == other)
21833 
 
21834 
class addCartEvent_args:
21835 
  """
21836 
  Attributes:
21837 
   - cartEvents
21838 
  """
21839 
 
21840 
  thrift_spec = (
21841 
    None, # 0
21842 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
21843 
  )
21844 
 
21845 
  def __init__(self, cartEvents=None,):
21846 
    self.cartEvents = cartEvents
21847 
 
21848 
  def read(self, iprot):
21849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21851 
      return
21852 
    iprot.readStructBegin()
21853 
    while True:
21854 
      (fname, ftype, fid) = iprot.readFieldBegin()
21855 
      if ftype == TType.STOP:
21856 
        break
21857 
      if fid == 1:
21858 
        if ftype == TType.STRUCT:
21859 
          self.cartEvents = CartEvents()
21860 
          self.cartEvents.read(iprot)
21861 
        else:
21862 
          iprot.skip(ftype)
21863 
      else:
21864 
        iprot.skip(ftype)
21865 
      iprot.readFieldEnd()
21866 
    iprot.readStructEnd()
21867 
 
21868 
  def write(self, oprot):
21869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21871 
      return
21872 
    oprot.writeStructBegin('addCartEvent_args')
21873 
    if self.cartEvents is not None:
21874 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
21875 
      self.cartEvents.write(oprot)
21876 
      oprot.writeFieldEnd()
21877 
    oprot.writeFieldStop()
21878 
    oprot.writeStructEnd()
21879 
 
21880 
  def validate(self):
21881 
    return
21882 
 
21883 
 
21884 
  def __repr__(self):
21885 
    L = ['%s=%r' % (key, value)
21886 
      for key, value in self.__dict__.iteritems()]
21887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21888 
 
21889 
  def __eq__(self, other):
21890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21891 
 
21892 
  def __ne__(self, other):
21893 
    return not (self == other)
21894 
 
21895 
class addCartEvent_result:
21896 
 
21897 
  thrift_spec = (
21898 
  )
21899 
 
21900 
  def read(self, iprot):
21901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21903 
      return
21904 
    iprot.readStructBegin()
21905 
    while True:
21906 
      (fname, ftype, fid) = iprot.readFieldBegin()
21907 
      if ftype == TType.STOP:
21908 
        break
21909 
      else:
21910 
        iprot.skip(ftype)
21911 
      iprot.readFieldEnd()
21912 
    iprot.readStructEnd()
21913 
 
21914 
  def write(self, oprot):
21915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21917 
      return
21918 
    oprot.writeStructBegin('addCartEvent_result')
21919 
    oprot.writeFieldStop()
21920 
    oprot.writeStructEnd()
21921 
 
21922 
  def validate(self):
21923 
    return
21924 
 
21925 
 
21926 
  def __repr__(self):
21927 
    L = ['%s=%r' % (key, value)
21928 
      for key, value in self.__dict__.iteritems()]
21929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21930 
 
21931 
  def __eq__(self, other):
21932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21933 
 
21934 
  def __ne__(self, other):
21935 
    return not (self == other)
8139 kshitij.so 21936 
 
8182 amar.kumar 21937 
class addEbayItem_args:
21938 
  """
21939 
  Attributes:
21940 
   - ebayItem
21941 
  """
21942 
 
21943 
  thrift_spec = (
21944 
    None, # 0
21945 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21946 
  )
21947 
 
21948 
  def __init__(self, ebayItem=None,):
21949 
    self.ebayItem = ebayItem
21950 
 
21951 
  def read(self, iprot):
21952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21954 
      return
21955 
    iprot.readStructBegin()
21956 
    while True:
21957 
      (fname, ftype, fid) = iprot.readFieldBegin()
21958 
      if ftype == TType.STOP:
21959 
        break
21960 
      if fid == 1:
21961 
        if ftype == TType.STRUCT:
21962 
          self.ebayItem = EbayItem()
21963 
          self.ebayItem.read(iprot)
21964 
        else:
21965 
          iprot.skip(ftype)
21966 
      else:
21967 
        iprot.skip(ftype)
21968 
      iprot.readFieldEnd()
21969 
    iprot.readStructEnd()
21970 
 
21971 
  def write(self, oprot):
21972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21974 
      return
21975 
    oprot.writeStructBegin('addEbayItem_args')
21976 
    if self.ebayItem is not None:
21977 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21978 
      self.ebayItem.write(oprot)
21979 
      oprot.writeFieldEnd()
21980 
    oprot.writeFieldStop()
21981 
    oprot.writeStructEnd()
21982 
 
21983 
  def validate(self):
21984 
    return
21985 
 
21986 
 
21987 
  def __repr__(self):
21988 
    L = ['%s=%r' % (key, value)
21989 
      for key, value in self.__dict__.iteritems()]
21990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21991 
 
21992 
  def __eq__(self, other):
21993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21994 
 
21995 
  def __ne__(self, other):
21996 
    return not (self == other)
21997 
 
21998 
class addEbayItem_result:
21999 
 
22000 
  thrift_spec = (
22001 
  )
22002 
 
22003 
  def read(self, iprot):
22004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22006 
      return
22007 
    iprot.readStructBegin()
22008 
    while True:
22009 
      (fname, ftype, fid) = iprot.readFieldBegin()
22010 
      if ftype == TType.STOP:
22011 
        break
22012 
      else:
22013 
        iprot.skip(ftype)
22014 
      iprot.readFieldEnd()
22015 
    iprot.readStructEnd()
22016 
 
22017 
  def write(self, oprot):
22018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22020 
      return
22021 
    oprot.writeStructBegin('addEbayItem_result')
22022 
    oprot.writeFieldStop()
22023 
    oprot.writeStructEnd()
22024 
 
22025 
  def validate(self):
22026 
    return
22027 
 
22028 
 
22029 
  def __repr__(self):
22030 
    L = ['%s=%r' % (key, value)
22031 
      for key, value in self.__dict__.iteritems()]
22032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22033 
 
22034 
  def __eq__(self, other):
22035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22036 
 
22037 
  def __ne__(self, other):
22038 
    return not (self == other)
22039 
 
22040 
class getEbayItem_args:
22041 
  """
22042 
  Attributes:
22043 
   - listingId
22044 
  """
22045 
 
22046 
  thrift_spec = (
22047 
    None, # 0
22048 
    (1, TType.STRING, 'listingId', None, None, ), # 1
22049 
  )
22050 
 
22051 
  def __init__(self, listingId=None,):
22052 
    self.listingId = listingId
22053 
 
22054 
  def read(self, iprot):
22055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22057 
      return
22058 
    iprot.readStructBegin()
22059 
    while True:
22060 
      (fname, ftype, fid) = iprot.readFieldBegin()
22061 
      if ftype == TType.STOP:
22062 
        break
22063 
      if fid == 1:
22064 
        if ftype == TType.STRING:
22065 
          self.listingId = iprot.readString();
22066 
        else:
22067 
          iprot.skip(ftype)
22068 
      else:
22069 
        iprot.skip(ftype)
22070 
      iprot.readFieldEnd()
22071 
    iprot.readStructEnd()
22072 
 
22073 
  def write(self, oprot):
22074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22076 
      return
22077 
    oprot.writeStructBegin('getEbayItem_args')
22078 
    if self.listingId is not None:
22079 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
22080 
      oprot.writeString(self.listingId)
22081 
      oprot.writeFieldEnd()
22082 
    oprot.writeFieldStop()
22083 
    oprot.writeStructEnd()
22084 
 
22085 
  def validate(self):
22086 
    return
22087 
 
22088 
 
22089 
  def __repr__(self):
22090 
    L = ['%s=%r' % (key, value)
22091 
      for key, value in self.__dict__.iteritems()]
22092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22093 
 
22094 
  def __eq__(self, other):
22095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22096 
 
22097 
  def __ne__(self, other):
22098 
    return not (self == other)
22099 
 
22100 
class getEbayItem_result:
22101 
  """
22102 
  Attributes:
22103 
   - success
22104 
  """
22105 
 
22106 
  thrift_spec = (
22107 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
22108 
  )
22109 
 
22110 
  def __init__(self, success=None,):
22111 
    self.success = success
22112 
 
22113 
  def read(self, iprot):
22114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22116 
      return
22117 
    iprot.readStructBegin()
22118 
    while True:
22119 
      (fname, ftype, fid) = iprot.readFieldBegin()
22120 
      if ftype == TType.STOP:
22121 
        break
22122 
      if fid == 0:
22123 
        if ftype == TType.STRUCT:
22124 
          self.success = EbayItem()
22125 
          self.success.read(iprot)
22126 
        else:
22127 
          iprot.skip(ftype)
22128 
      else:
22129 
        iprot.skip(ftype)
22130 
      iprot.readFieldEnd()
22131 
    iprot.readStructEnd()
22132 
 
22133 
  def write(self, oprot):
22134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22136 
      return
22137 
    oprot.writeStructBegin('getEbayItem_result')
22138 
    if self.success is not None:
22139 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22140 
      self.success.write(oprot)
22141 
      oprot.writeFieldEnd()
22142 
    oprot.writeFieldStop()
22143 
    oprot.writeStructEnd()
22144 
 
22145 
  def validate(self):
22146 
    return
22147 
 
22148 
 
22149 
  def __repr__(self):
22150 
    L = ['%s=%r' % (key, value)
22151 
      for key, value in self.__dict__.iteritems()]
22152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22153 
 
22154 
  def __eq__(self, other):
22155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22156 
 
22157 
  def __ne__(self, other):
22158 
    return not (self == other)
22159 
 
22160 
class updateEbayItem_args:
22161 
  """
22162 
  Attributes:
22163 
   - ebayItem
22164 
  """
22165 
 
22166 
  thrift_spec = (
22167 
    None, # 0
22168 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22169 
  )
22170 
 
22171 
  def __init__(self, ebayItem=None,):
22172 
    self.ebayItem = ebayItem
22173 
 
22174 
  def read(self, iprot):
22175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22177 
      return
22178 
    iprot.readStructBegin()
22179 
    while True:
22180 
      (fname, ftype, fid) = iprot.readFieldBegin()
22181 
      if ftype == TType.STOP:
22182 
        break
22183 
      if fid == 1:
22184 
        if ftype == TType.STRUCT:
22185 
          self.ebayItem = EbayItem()
22186 
          self.ebayItem.read(iprot)
22187 
        else:
22188 
          iprot.skip(ftype)
22189 
      else:
22190 
        iprot.skip(ftype)
22191 
      iprot.readFieldEnd()
22192 
    iprot.readStructEnd()
22193 
 
22194 
  def write(self, oprot):
22195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22197 
      return
22198 
    oprot.writeStructBegin('updateEbayItem_args')
22199 
    if self.ebayItem is not None:
22200 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22201 
      self.ebayItem.write(oprot)
22202 
      oprot.writeFieldEnd()
22203 
    oprot.writeFieldStop()
22204 
    oprot.writeStructEnd()
22205 
 
22206 
  def validate(self):
22207 
    return
22208 
 
22209 
 
22210 
  def __repr__(self):
22211 
    L = ['%s=%r' % (key, value)
22212 
      for key, value in self.__dict__.iteritems()]
22213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22214 
 
22215 
  def __eq__(self, other):
22216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22217 
 
22218 
  def __ne__(self, other):
22219 
    return not (self == other)
22220 
 
22221 
class updateEbayItem_result:
22222 
 
22223 
  thrift_spec = (
22224 
  )
22225 
 
22226 
  def read(self, iprot):
22227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22229 
      return
22230 
    iprot.readStructBegin()
22231 
    while True:
22232 
      (fname, ftype, fid) = iprot.readFieldBegin()
22233 
      if ftype == TType.STOP:
22234 
        break
22235 
      else:
22236 
        iprot.skip(ftype)
22237 
      iprot.readFieldEnd()
22238 
    iprot.readStructEnd()
22239 
 
22240 
  def write(self, oprot):
22241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22243 
      return
22244 
    oprot.writeStructBegin('updateEbayItem_result')
22245 
    oprot.writeFieldStop()
22246 
    oprot.writeStructEnd()
22247 
 
22248 
  def validate(self):
22249 
    return
22250 
 
22251 
 
22252 
  def __repr__(self):
22253 
    L = ['%s=%r' % (key, value)
22254 
      for key, value in self.__dict__.iteritems()]
22255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22256 
 
22257 
  def __eq__(self, other):
22258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22259 
 
22260 
  def __ne__(self, other):
22261 
    return not (self == other)
22262 
 
8139 kshitij.so 22263 
class getAmazonListedItems_args:
22264 
  """
22265 
  Attributes:
22266 
   - offset
22267 
   - limit
22268 
  """
22269 
 
22270 
  thrift_spec = (
22271 
    None, # 0
22272 
    (1, TType.I64, 'offset', None, None, ), # 1
22273 
    (2, TType.I64, 'limit', None, None, ), # 2
22274 
  )
22275 
 
22276 
  def __init__(self, offset=None, limit=None,):
22277 
    self.offset = offset
22278 
    self.limit = limit
22279 
 
22280 
  def read(self, iprot):
22281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22283 
      return
22284 
    iprot.readStructBegin()
22285 
    while True:
22286 
      (fname, ftype, fid) = iprot.readFieldBegin()
22287 
      if ftype == TType.STOP:
22288 
        break
22289 
      if fid == 1:
22290 
        if ftype == TType.I64:
22291 
          self.offset = iprot.readI64();
22292 
        else:
22293 
          iprot.skip(ftype)
22294 
      elif fid == 2:
22295 
        if ftype == TType.I64:
22296 
          self.limit = iprot.readI64();
22297 
        else:
22298 
          iprot.skip(ftype)
22299 
      else:
22300 
        iprot.skip(ftype)
22301 
      iprot.readFieldEnd()
22302 
    iprot.readStructEnd()
22303 
 
22304 
  def write(self, oprot):
22305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22307 
      return
22308 
    oprot.writeStructBegin('getAmazonListedItems_args')
22309 
    if self.offset is not None:
22310 
      oprot.writeFieldBegin('offset', TType.I64, 1)
22311 
      oprot.writeI64(self.offset)
22312 
      oprot.writeFieldEnd()
22313 
    if self.limit is not None:
22314 
      oprot.writeFieldBegin('limit', TType.I64, 2)
22315 
      oprot.writeI64(self.limit)
22316 
      oprot.writeFieldEnd()
22317 
    oprot.writeFieldStop()
22318 
    oprot.writeStructEnd()
22319 
 
22320 
  def validate(self):
22321 
    return
22322 
 
22323 
 
22324 
  def __repr__(self):
22325 
    L = ['%s=%r' % (key, value)
22326 
      for key, value in self.__dict__.iteritems()]
22327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22328 
 
22329 
  def __eq__(self, other):
22330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22331 
 
22332 
  def __ne__(self, other):
22333 
    return not (self == other)
22334 
 
22335 
class getAmazonListedItems_result:
22336 
  """
22337 
  Attributes:
22338 
   - success
22339 
  """
22340 
 
22341 
  thrift_spec = (
22342 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22343 
  )
22344 
 
22345 
  def __init__(self, success=None,):
22346 
    self.success = success
22347 
 
22348 
  def read(self, iprot):
22349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22351 
      return
22352 
    iprot.readStructBegin()
22353 
    while True:
22354 
      (fname, ftype, fid) = iprot.readFieldBegin()
22355 
      if ftype == TType.STOP:
22356 
        break
22357 
      if fid == 0:
22358 
        if ftype == TType.LIST:
22359 
          self.success = []
9155 kshitij.so 22360 
          (_etype477, _size474) = iprot.readListBegin()
22361 
          for _i478 in xrange(_size474):
22362 
            _elem479 = Amazonlisted()
22363 
            _elem479.read(iprot)
22364 
            self.success.append(_elem479)
8139 kshitij.so 22365 
          iprot.readListEnd()
22366 
        else:
22367 
          iprot.skip(ftype)
22368 
      else:
22369 
        iprot.skip(ftype)
22370 
      iprot.readFieldEnd()
22371 
    iprot.readStructEnd()
22372 
 
22373 
  def write(self, oprot):
22374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22376 
      return
22377 
    oprot.writeStructBegin('getAmazonListedItems_result')
22378 
    if self.success is not None:
22379 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22380 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22381 
      for iter480 in self.success:
22382 
        iter480.write(oprot)
8139 kshitij.so 22383 
      oprot.writeListEnd()
22384 
      oprot.writeFieldEnd()
22385 
    oprot.writeFieldStop()
22386 
    oprot.writeStructEnd()
22387 
 
22388 
  def validate(self):
22389 
    return
22390 
 
22391 
 
22392 
  def __repr__(self):
22393 
    L = ['%s=%r' % (key, value)
22394 
      for key, value in self.__dict__.iteritems()]
22395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22396 
 
22397 
  def __eq__(self, other):
22398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22399 
 
22400 
  def __ne__(self, other):
22401 
    return not (self == other)
8168 kshitij.so 22402 
 
22403 
class updateAmazonAttributesInBulk_args:
22404 
  """
22405 
  Attributes:
22406 
   - amazonlisted
22407 
  """
22408 
 
22409 
  thrift_spec = (
22410 
    None, # 0
22411 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
22412 
  )
22413 
 
22414 
  def __init__(self, amazonlisted=None,):
22415 
    self.amazonlisted = amazonlisted
22416 
 
22417 
  def read(self, iprot):
22418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22420 
      return
22421 
    iprot.readStructBegin()
22422 
    while True:
22423 
      (fname, ftype, fid) = iprot.readFieldBegin()
22424 
      if ftype == TType.STOP:
22425 
        break
22426 
      if fid == 1:
22427 
        if ftype == TType.MAP:
22428 
          self.amazonlisted = {}
9155 kshitij.so 22429 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
22430 
          for _i485 in xrange(_size481):
22431 
            _key486 = iprot.readI64();
22432 
            _val487 = Amazonlisted()
22433 
            _val487.read(iprot)
22434 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 22435 
          iprot.readMapEnd()
22436 
        else:
22437 
          iprot.skip(ftype)
22438 
      else:
22439 
        iprot.skip(ftype)
22440 
      iprot.readFieldEnd()
22441 
    iprot.readStructEnd()
22442 
 
22443 
  def write(self, oprot):
22444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22446 
      return
22447 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
22448 
    if self.amazonlisted is not None:
22449 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
22450 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 22451 
      for kiter488,viter489 in self.amazonlisted.items():
22452 
        oprot.writeI64(kiter488)
22453 
        viter489.write(oprot)
8168 kshitij.so 22454 
      oprot.writeMapEnd()
22455 
      oprot.writeFieldEnd()
22456 
    oprot.writeFieldStop()
22457 
    oprot.writeStructEnd()
22458 
 
22459 
  def validate(self):
22460 
    return
22461 
 
22462 
 
22463 
  def __repr__(self):
22464 
    L = ['%s=%r' % (key, value)
22465 
      for key, value in self.__dict__.iteritems()]
22466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22467 
 
22468 
  def __eq__(self, other):
22469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22470 
 
22471 
  def __ne__(self, other):
22472 
    return not (self == other)
22473 
 
22474 
class updateAmazonAttributesInBulk_result:
22475 
  """
22476 
  Attributes:
22477 
   - success
22478 
  """
22479 
 
22480 
  thrift_spec = (
22481 
    (0, TType.BOOL, 'success', None, None, ), # 0
22482 
  )
22483 
 
22484 
  def __init__(self, success=None,):
22485 
    self.success = success
22486 
 
22487 
  def read(self, iprot):
22488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22490 
      return
22491 
    iprot.readStructBegin()
22492 
    while True:
22493 
      (fname, ftype, fid) = iprot.readFieldBegin()
22494 
      if ftype == TType.STOP:
22495 
        break
22496 
      if fid == 0:
22497 
        if ftype == TType.BOOL:
22498 
          self.success = iprot.readBool();
22499 
        else:
22500 
          iprot.skip(ftype)
22501 
      else:
22502 
        iprot.skip(ftype)
22503 
      iprot.readFieldEnd()
22504 
    iprot.readStructEnd()
22505 
 
22506 
  def write(self, oprot):
22507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22509 
      return
22510 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
22511 
    if self.success is not None:
22512 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22513 
      oprot.writeBool(self.success)
22514 
      oprot.writeFieldEnd()
22515 
    oprot.writeFieldStop()
22516 
    oprot.writeStructEnd()
22517 
 
22518 
  def validate(self):
22519 
    return
22520 
 
22521 
 
22522 
  def __repr__(self):
22523 
    L = ['%s=%r' % (key, value)
22524 
      for key, value in self.__dict__.iteritems()]
22525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22526 
 
22527 
  def __eq__(self, other):
22528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22529 
 
22530 
  def __ne__(self, other):
22531 
    return not (self == other)
8379 vikram.rag 22532 
 
22533 
class getAllItemstoListOnFba_args:
22534 
 
22535 
  thrift_spec = (
22536 
  )
22537 
 
22538 
  def read(self, iprot):
22539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22541 
      return
22542 
    iprot.readStructBegin()
22543 
    while True:
22544 
      (fname, ftype, fid) = iprot.readFieldBegin()
22545 
      if ftype == TType.STOP:
22546 
        break
22547 
      else:
22548 
        iprot.skip(ftype)
22549 
      iprot.readFieldEnd()
22550 
    iprot.readStructEnd()
22551 
 
22552 
  def write(self, oprot):
22553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22555 
      return
22556 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
22557 
    oprot.writeFieldStop()
22558 
    oprot.writeStructEnd()
22559 
 
22560 
  def validate(self):
22561 
    return
22562 
 
22563 
 
22564 
  def __repr__(self):
22565 
    L = ['%s=%r' % (key, value)
22566 
      for key, value in self.__dict__.iteritems()]
22567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22568 
 
22569 
  def __eq__(self, other):
22570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22571 
 
22572 
  def __ne__(self, other):
22573 
    return not (self == other)
22574 
 
22575 
class getAllItemstoListOnFba_result:
22576 
  """
22577 
  Attributes:
22578 
   - success
22579 
  """
22580 
 
22581 
  thrift_spec = (
22582 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22583 
  )
22584 
 
22585 
  def __init__(self, success=None,):
22586 
    self.success = success
22587 
 
22588 
  def read(self, iprot):
22589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22591 
      return
22592 
    iprot.readStructBegin()
22593 
    while True:
22594 
      (fname, ftype, fid) = iprot.readFieldBegin()
22595 
      if ftype == TType.STOP:
22596 
        break
22597 
      if fid == 0:
22598 
        if ftype == TType.LIST:
22599 
          self.success = []
9155 kshitij.so 22600 
          (_etype493, _size490) = iprot.readListBegin()
22601 
          for _i494 in xrange(_size490):
22602 
            _elem495 = Amazonlisted()
22603 
            _elem495.read(iprot)
22604 
            self.success.append(_elem495)
8379 vikram.rag 22605 
          iprot.readListEnd()
22606 
        else:
22607 
          iprot.skip(ftype)
22608 
      else:
22609 
        iprot.skip(ftype)
22610 
      iprot.readFieldEnd()
22611 
    iprot.readStructEnd()
22612 
 
22613 
  def write(self, oprot):
22614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22616 
      return
22617 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
22618 
    if self.success is not None:
22619 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22620 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22621 
      for iter496 in self.success:
22622 
        iter496.write(oprot)
8379 vikram.rag 22623 
      oprot.writeListEnd()
22624 
      oprot.writeFieldEnd()
22625 
    oprot.writeFieldStop()
22626 
    oprot.writeStructEnd()
22627 
 
22628 
  def validate(self):
22629 
    return
22630 
 
22631 
 
22632 
  def __repr__(self):
22633 
    L = ['%s=%r' % (key, value)
22634 
      for key, value in self.__dict__.iteritems()]
22635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22636 
 
22637 
  def __eq__(self, other):
22638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22639 
 
22640 
  def __ne__(self, other):
22641 
    return not (self == other)
22642 
 
22643 
class getAllItemstoListOnNonFba_args:
22644 
 
22645 
  thrift_spec = (
22646 
  )
22647 
 
22648 
  def read(self, iprot):
22649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22651 
      return
22652 
    iprot.readStructBegin()
22653 
    while True:
22654 
      (fname, ftype, fid) = iprot.readFieldBegin()
22655 
      if ftype == TType.STOP:
22656 
        break
22657 
      else:
22658 
        iprot.skip(ftype)
22659 
      iprot.readFieldEnd()
22660 
    iprot.readStructEnd()
22661 
 
22662 
  def write(self, oprot):
22663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22665 
      return
22666 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
22667 
    oprot.writeFieldStop()
22668 
    oprot.writeStructEnd()
22669 
 
22670 
  def validate(self):
22671 
    return
22672 
 
22673 
 
22674 
  def __repr__(self):
22675 
    L = ['%s=%r' % (key, value)
22676 
      for key, value in self.__dict__.iteritems()]
22677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22678 
 
22679 
  def __eq__(self, other):
22680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22681 
 
22682 
  def __ne__(self, other):
22683 
    return not (self == other)
22684 
 
22685 
class getAllItemstoListOnNonFba_result:
22686 
  """
22687 
  Attributes:
22688 
   - success
22689 
  """
22690 
 
22691 
  thrift_spec = (
22692 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22693 
  )
22694 
 
22695 
  def __init__(self, success=None,):
22696 
    self.success = success
22697 
 
22698 
  def read(self, iprot):
22699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22701 
      return
22702 
    iprot.readStructBegin()
22703 
    while True:
22704 
      (fname, ftype, fid) = iprot.readFieldBegin()
22705 
      if ftype == TType.STOP:
22706 
        break
22707 
      if fid == 0:
22708 
        if ftype == TType.LIST:
22709 
          self.success = []
9155 kshitij.so 22710 
          (_etype500, _size497) = iprot.readListBegin()
22711 
          for _i501 in xrange(_size497):
22712 
            _elem502 = Amazonlisted()
22713 
            _elem502.read(iprot)
22714 
            self.success.append(_elem502)
8379 vikram.rag 22715 
          iprot.readListEnd()
22716 
        else:
22717 
          iprot.skip(ftype)
22718 
      else:
22719 
        iprot.skip(ftype)
22720 
      iprot.readFieldEnd()
22721 
    iprot.readStructEnd()
22722 
 
22723 
  def write(self, oprot):
22724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22726 
      return
22727 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
22728 
    if self.success is not None:
22729 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22730 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22731 
      for iter503 in self.success:
22732 
        iter503.write(oprot)
8379 vikram.rag 22733 
      oprot.writeListEnd()
22734 
      oprot.writeFieldEnd()
22735 
    oprot.writeFieldStop()
22736 
    oprot.writeStructEnd()
22737 
 
22738 
  def validate(self):
22739 
    return
22740 
 
22741 
 
22742 
  def __repr__(self):
22743 
    L = ['%s=%r' % (key, value)
22744 
      for key, value in self.__dict__.iteritems()]
22745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22746 
 
22747 
  def __eq__(self, other):
22748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22749 
 
22750 
  def __ne__(self, other):
22751 
    return not (self == other)
8616 vikram.rag 22752 
 
9242 kshitij.so 22753 
class updateAsin_args:
22754 
  """
22755 
  Attributes:
22756 
   - item
22757 
  """
8616 vikram.rag 22758 
 
22759 
  thrift_spec = (
9242 kshitij.so 22760 
    None, # 0
22761 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 22762 
  )
22763 
 
9242 kshitij.so 22764 
  def __init__(self, item=None,):
22765 
    self.item = item
22766 
 
8616 vikram.rag 22767 
  def read(self, iprot):
22768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22770 
      return
22771 
    iprot.readStructBegin()
22772 
    while True:
22773 
      (fname, ftype, fid) = iprot.readFieldBegin()
22774 
      if ftype == TType.STOP:
22775 
        break
9242 kshitij.so 22776 
      if fid == 1:
22777 
        if ftype == TType.MAP:
22778 
          self.item = {}
22779 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
22780 
          for _i508 in xrange(_size504):
22781 
            _key509 = iprot.readI64();
22782 
            _val510 = Item()
22783 
            _val510.read(iprot)
22784 
            self.item[_key509] = _val510
22785 
          iprot.readMapEnd()
22786 
        else:
22787 
          iprot.skip(ftype)
8616 vikram.rag 22788 
      else:
22789 
        iprot.skip(ftype)
22790 
      iprot.readFieldEnd()
22791 
    iprot.readStructEnd()
22792 
 
22793 
  def write(self, oprot):
22794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22796 
      return
9242 kshitij.so 22797 
    oprot.writeStructBegin('updateAsin_args')
22798 
    if self.item is not None:
22799 
      oprot.writeFieldBegin('item', TType.MAP, 1)
22800 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
22801 
      for kiter511,viter512 in self.item.items():
22802 
        oprot.writeI64(kiter511)
22803 
        viter512.write(oprot)
22804 
      oprot.writeMapEnd()
22805 
      oprot.writeFieldEnd()
8616 vikram.rag 22806 
    oprot.writeFieldStop()
22807 
    oprot.writeStructEnd()
22808 
 
22809 
  def validate(self):
22810 
    return
22811 
 
22812 
 
22813 
  def __repr__(self):
22814 
    L = ['%s=%r' % (key, value)
22815 
      for key, value in self.__dict__.iteritems()]
22816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22817 
 
22818 
  def __eq__(self, other):
22819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22820 
 
22821 
  def __ne__(self, other):
22822 
    return not (self == other)
22823 
 
9242 kshitij.so 22824 
class updateAsin_result:
8616 vikram.rag 22825 
 
22826 
  thrift_spec = (
22827 
  )
22828 
 
22829 
  def read(self, iprot):
22830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22832 
      return
22833 
    iprot.readStructBegin()
22834 
    while True:
22835 
      (fname, ftype, fid) = iprot.readFieldBegin()
22836 
      if ftype == TType.STOP:
22837 
        break
22838 
      else:
22839 
        iprot.skip(ftype)
22840 
      iprot.readFieldEnd()
22841 
    iprot.readStructEnd()
22842 
 
22843 
  def write(self, oprot):
22844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22846 
      return
9242 kshitij.so 22847 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 22848 
    oprot.writeFieldStop()
22849 
    oprot.writeStructEnd()
22850 
 
22851 
  def validate(self):
22852 
    return
22853 
 
22854 
 
22855 
  def __repr__(self):
22856 
    L = ['%s=%r' % (key, value)
22857 
      for key, value in self.__dict__.iteritems()]
22858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22859 
 
22860 
  def __eq__(self, other):
22861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22862 
 
22863 
  def __ne__(self, other):
22864 
    return not (self == other)
8619 kshitij.so 22865 
 
9242 kshitij.so 22866 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 22867 
  """
22868 
  Attributes:
9242 kshitij.so 22869 
   - snapdealitem
8619 kshitij.so 22870 
  """
22871 
 
9242 kshitij.so 22872 
  thrift_spec = None
22873 
  def __init__(self, snapdealitem=None,):
22874 
    self.snapdealitem = snapdealitem
8619 kshitij.so 22875 
 
22876 
  def read(self, iprot):
22877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22879 
      return
22880 
    iprot.readStructBegin()
22881 
    while True:
22882 
      (fname, ftype, fid) = iprot.readFieldBegin()
22883 
      if ftype == TType.STOP:
22884 
        break
9242 kshitij.so 22885 
      if fid == -1:
22886 
        if ftype == TType.STRUCT:
22887 
          self.snapdealitem = SnapdealItem()
22888 
          self.snapdealitem.read(iprot)
8619 kshitij.so 22889 
        else:
22890 
          iprot.skip(ftype)
22891 
      else:
22892 
        iprot.skip(ftype)
22893 
      iprot.readFieldEnd()
22894 
    iprot.readStructEnd()
22895 
 
22896 
  def write(self, oprot):
22897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22899 
      return
9242 kshitij.so 22900 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
22901 
    if self.snapdealitem is not None:
22902 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
22903 
      self.snapdealitem.write(oprot)
8619 kshitij.so 22904 
      oprot.writeFieldEnd()
22905 
    oprot.writeFieldStop()
22906 
    oprot.writeStructEnd()
22907 
 
22908 
  def validate(self):
22909 
    return
22910 
 
22911 
 
22912 
  def __repr__(self):
22913 
    L = ['%s=%r' % (key, value)
22914 
      for key, value in self.__dict__.iteritems()]
22915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22916 
 
22917 
  def __eq__(self, other):
22918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22919 
 
22920 
  def __ne__(self, other):
22921 
    return not (self == other)
22922 
 
9242 kshitij.so 22923 
class addOrUpdateSnapdealItem_result:
22924 
  """
22925 
  Attributes:
22926 
   - success
22927 
  """
8619 kshitij.so 22928 
 
22929 
  thrift_spec = (
9242 kshitij.so 22930 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 22931 
  )
22932 
 
9242 kshitij.so 22933 
  def __init__(self, success=None,):
22934 
    self.success = success
22935 
 
8619 kshitij.so 22936 
  def read(self, iprot):
22937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22939 
      return
22940 
    iprot.readStructBegin()
22941 
    while True:
22942 
      (fname, ftype, fid) = iprot.readFieldBegin()
22943 
      if ftype == TType.STOP:
22944 
        break
9242 kshitij.so 22945 
      if fid == 0:
22946 
        if ftype == TType.BOOL:
22947 
          self.success = iprot.readBool();
22948 
        else:
22949 
          iprot.skip(ftype)
8619 kshitij.so 22950 
      else:
22951 
        iprot.skip(ftype)
22952 
      iprot.readFieldEnd()
22953 
    iprot.readStructEnd()
22954 
 
22955 
  def write(self, oprot):
22956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22958 
      return
9242 kshitij.so 22959 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
22960 
    if self.success is not None:
22961 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22962 
      oprot.writeBool(self.success)
22963 
      oprot.writeFieldEnd()
8619 kshitij.so 22964 
    oprot.writeFieldStop()
22965 
    oprot.writeStructEnd()
22966 
 
22967 
  def validate(self):
22968 
    return
22969 
 
22970 
 
22971 
  def __repr__(self):
22972 
    L = ['%s=%r' % (key, value)
22973 
      for key, value in self.__dict__.iteritems()]
22974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22975 
 
22976 
  def __eq__(self, other):
22977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22978 
 
22979 
  def __ne__(self, other):
22980 
    return not (self == other)
8739 vikram.rag 22981 
 
9242 kshitij.so 22982 
class getSnapdealItem_args:
8739 vikram.rag 22983 
  """
22984 
  Attributes:
9242 kshitij.so 22985 
   - item_id
8739 vikram.rag 22986 
  """
22987 
 
9242 kshitij.so 22988 
  thrift_spec = (
22989 
    None, # 0
22990 
    (1, TType.I64, 'item_id', None, None, ), # 1
22991 
  )
8739 vikram.rag 22992 
 
9242 kshitij.so 22993 
  def __init__(self, item_id=None,):
22994 
    self.item_id = item_id
22995 
 
8739 vikram.rag 22996 
  def read(self, iprot):
22997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22999 
      return
23000 
    iprot.readStructBegin()
23001 
    while True:
23002 
      (fname, ftype, fid) = iprot.readFieldBegin()
23003 
      if ftype == TType.STOP:
23004 
        break
9242 kshitij.so 23005 
      if fid == 1:
23006 
        if ftype == TType.I64:
23007 
          self.item_id = iprot.readI64();
8739 vikram.rag 23008 
        else:
23009 
          iprot.skip(ftype)
23010 
      else:
23011 
        iprot.skip(ftype)
23012 
      iprot.readFieldEnd()
23013 
    iprot.readStructEnd()
23014 
 
23015 
  def write(self, oprot):
23016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23018 
      return
9242 kshitij.so 23019 
    oprot.writeStructBegin('getSnapdealItem_args')
23020 
    if self.item_id is not None:
23021 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23022 
      oprot.writeI64(self.item_id)
8739 vikram.rag 23023 
      oprot.writeFieldEnd()
23024 
    oprot.writeFieldStop()
23025 
    oprot.writeStructEnd()
23026 
 
23027 
  def validate(self):
23028 
    return
23029 
 
23030 
 
23031 
  def __repr__(self):
23032 
    L = ['%s=%r' % (key, value)
23033 
      for key, value in self.__dict__.iteritems()]
23034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23035 
 
23036 
  def __eq__(self, other):
23037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23038 
 
23039 
  def __ne__(self, other):
23040 
    return not (self == other)
23041 
 
9242 kshitij.so 23042 
class getSnapdealItem_result:
8739 vikram.rag 23043 
  """
23044 
  Attributes:
23045 
   - success
23046 
  """
23047 
 
23048 
  thrift_spec = (
9242 kshitij.so 23049 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 23050 
  )
23051 
 
23052 
  def __init__(self, success=None,):
23053 
    self.success = success
23054 
 
23055 
  def read(self, iprot):
23056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23058 
      return
23059 
    iprot.readStructBegin()
23060 
    while True:
23061 
      (fname, ftype, fid) = iprot.readFieldBegin()
23062 
      if ftype == TType.STOP:
23063 
        break
23064 
      if fid == 0:
9242 kshitij.so 23065 
        if ftype == TType.STRUCT:
23066 
          self.success = SnapdealItem()
23067 
          self.success.read(iprot)
8739 vikram.rag 23068 
        else:
23069 
          iprot.skip(ftype)
23070 
      else:
23071 
        iprot.skip(ftype)
23072 
      iprot.readFieldEnd()
23073 
    iprot.readStructEnd()
23074 
 
23075 
  def write(self, oprot):
23076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23078 
      return
9242 kshitij.so 23079 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 23080 
    if self.success is not None:
9242 kshitij.so 23081 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23082 
      self.success.write(oprot)
8739 vikram.rag 23083 
      oprot.writeFieldEnd()
23084 
    oprot.writeFieldStop()
23085 
    oprot.writeStructEnd()
23086 
 
23087 
  def validate(self):
23088 
    return
23089 
 
23090 
 
23091 
  def __repr__(self):
23092 
    L = ['%s=%r' % (key, value)
23093 
      for key, value in self.__dict__.iteritems()]
23094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23095 
 
23096 
  def __eq__(self, other):
23097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23098 
 
23099 
  def __ne__(self, other):
23100 
    return not (self == other)
23101 
 
9242 kshitij.so 23102 
class getSnapdealItemDetails_args:
8739 vikram.rag 23103 
  """
23104 
  Attributes:
23105 
   - item_id
23106 
  """
23107 
 
23108 
  thrift_spec = (
23109 
    None, # 0
23110 
    (1, TType.I64, 'item_id', None, None, ), # 1
23111 
  )
23112 
 
23113 
  def __init__(self, item_id=None,):
23114 
    self.item_id = item_id
23115 
 
23116 
  def read(self, iprot):
23117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23119 
      return
23120 
    iprot.readStructBegin()
23121 
    while True:
23122 
      (fname, ftype, fid) = iprot.readFieldBegin()
23123 
      if ftype == TType.STOP:
23124 
        break
23125 
      if fid == 1:
23126 
        if ftype == TType.I64:
23127 
          self.item_id = iprot.readI64();
23128 
        else:
23129 
          iprot.skip(ftype)
23130 
      else:
23131 
        iprot.skip(ftype)
23132 
      iprot.readFieldEnd()
23133 
    iprot.readStructEnd()
23134 
 
23135 
  def write(self, oprot):
23136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23138 
      return
9242 kshitij.so 23139 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 23140 
    if self.item_id is not None:
23141 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23142 
      oprot.writeI64(self.item_id)
23143 
      oprot.writeFieldEnd()
23144 
    oprot.writeFieldStop()
23145 
    oprot.writeStructEnd()
23146 
 
23147 
  def validate(self):
23148 
    return
23149 
 
23150 
 
23151 
  def __repr__(self):
23152 
    L = ['%s=%r' % (key, value)
23153 
      for key, value in self.__dict__.iteritems()]
23154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23155 
 
23156 
  def __eq__(self, other):
23157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23158 
 
23159 
  def __ne__(self, other):
23160 
    return not (self == other)
23161 
 
9242 kshitij.so 23162 
class getSnapdealItemDetails_result:
8739 vikram.rag 23163 
  """
23164 
  Attributes:
23165 
   - success
23166 
  """
23167 
 
23168 
  thrift_spec = (
9242 kshitij.so 23169 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 23170 
  )
23171 
 
23172 
  def __init__(self, success=None,):
23173 
    self.success = success
23174 
 
23175 
  def read(self, iprot):
23176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23178 
      return
23179 
    iprot.readStructBegin()
23180 
    while True:
23181 
      (fname, ftype, fid) = iprot.readFieldBegin()
23182 
      if ftype == TType.STOP:
23183 
        break
23184 
      if fid == 0:
23185 
        if ftype == TType.STRUCT:
9242 kshitij.so 23186 
          self.success = SnapdealItemDetails()
8739 vikram.rag 23187 
          self.success.read(iprot)
23188 
        else:
23189 
          iprot.skip(ftype)
23190 
      else:
23191 
        iprot.skip(ftype)
23192 
      iprot.readFieldEnd()
23193 
    iprot.readStructEnd()
23194 
 
23195 
  def write(self, oprot):
23196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23198 
      return
9242 kshitij.so 23199 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 23200 
    if self.success is not None:
23201 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23202 
      self.success.write(oprot)
23203 
      oprot.writeFieldEnd()
23204 
    oprot.writeFieldStop()
23205 
    oprot.writeStructEnd()
23206 
 
23207 
  def validate(self):
23208 
    return
23209 
 
23210 
 
23211 
  def __repr__(self):
23212 
    L = ['%s=%r' % (key, value)
23213 
      for key, value in self.__dict__.iteritems()]
23214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23215 
 
23216 
  def __eq__(self, other):
23217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23218 
 
23219 
  def __ne__(self, other):
23220 
    return not (self == other)
23221 
 
23222 
class getAllSnapdealItems_args:
23223 
 
23224 
  thrift_spec = (
23225 
  )
23226 
 
23227 
  def read(self, iprot):
23228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23230 
      return
23231 
    iprot.readStructBegin()
23232 
    while True:
23233 
      (fname, ftype, fid) = iprot.readFieldBegin()
23234 
      if ftype == TType.STOP:
23235 
        break
23236 
      else:
23237 
        iprot.skip(ftype)
23238 
      iprot.readFieldEnd()
23239 
    iprot.readStructEnd()
23240 
 
23241 
  def write(self, oprot):
23242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23244 
      return
23245 
    oprot.writeStructBegin('getAllSnapdealItems_args')
23246 
    oprot.writeFieldStop()
23247 
    oprot.writeStructEnd()
23248 
 
23249 
  def validate(self):
23250 
    return
23251 
 
23252 
 
23253 
  def __repr__(self):
23254 
    L = ['%s=%r' % (key, value)
23255 
      for key, value in self.__dict__.iteritems()]
23256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23257 
 
23258 
  def __eq__(self, other):
23259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23260 
 
23261 
  def __ne__(self, other):
23262 
    return not (self == other)
23263 
 
23264 
class getAllSnapdealItems_result:
23265 
  """
23266 
  Attributes:
23267 
   - success
23268 
  """
23269 
 
23270 
  thrift_spec = (
9242 kshitij.so 23271 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 23272 
  )
23273 
 
23274 
  def __init__(self, success=None,):
23275 
    self.success = success
23276 
 
23277 
  def read(self, iprot):
23278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23280 
      return
23281 
    iprot.readStructBegin()
23282 
    while True:
23283 
      (fname, ftype, fid) = iprot.readFieldBegin()
23284 
      if ftype == TType.STOP:
23285 
        break
23286 
      if fid == 0:
23287 
        if ftype == TType.LIST:
23288 
          self.success = []
9242 kshitij.so 23289 
          (_etype516, _size513) = iprot.readListBegin()
23290 
          for _i517 in xrange(_size513):
23291 
            _elem518 = SnapdealItemDetails()
23292 
            _elem518.read(iprot)
23293 
            self.success.append(_elem518)
23294 
          iprot.readListEnd()
23295 
        else:
23296 
          iprot.skip(ftype)
23297 
      else:
23298 
        iprot.skip(ftype)
23299 
      iprot.readFieldEnd()
23300 
    iprot.readStructEnd()
23301 
 
23302 
  def write(self, oprot):
23303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23305 
      return
23306 
    oprot.writeStructBegin('getAllSnapdealItems_result')
23307 
    if self.success is not None:
23308 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23309 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23310 
      for iter519 in self.success:
23311 
        iter519.write(oprot)
23312 
      oprot.writeListEnd()
23313 
      oprot.writeFieldEnd()
23314 
    oprot.writeFieldStop()
23315 
    oprot.writeStructEnd()
23316 
 
23317 
  def validate(self):
23318 
    return
23319 
 
23320 
 
23321 
  def __repr__(self):
23322 
    L = ['%s=%r' % (key, value)
23323 
      for key, value in self.__dict__.iteritems()]
23324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23325 
 
23326 
  def __eq__(self, other):
23327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23328 
 
23329 
  def __ne__(self, other):
23330 
    return not (self == other)
23331 
 
23332 
class getSnapdealItems_args:
23333 
  """
23334 
  Attributes:
23335 
   - offset
23336 
   - limit
23337 
  """
23338 
 
23339 
  thrift_spec = (
23340 
    None, # 0
23341 
    (1, TType.I64, 'offset', None, None, ), # 1
23342 
    (2, TType.I64, 'limit', None, None, ), # 2
23343 
  )
23344 
 
23345 
  def __init__(self, offset=None, limit=None,):
23346 
    self.offset = offset
23347 
    self.limit = limit
23348 
 
23349 
  def read(self, iprot):
23350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23352 
      return
23353 
    iprot.readStructBegin()
23354 
    while True:
23355 
      (fname, ftype, fid) = iprot.readFieldBegin()
23356 
      if ftype == TType.STOP:
23357 
        break
23358 
      if fid == 1:
23359 
        if ftype == TType.I64:
23360 
          self.offset = iprot.readI64();
23361 
        else:
23362 
          iprot.skip(ftype)
23363 
      elif fid == 2:
23364 
        if ftype == TType.I64:
23365 
          self.limit = iprot.readI64();
23366 
        else:
23367 
          iprot.skip(ftype)
23368 
      else:
23369 
        iprot.skip(ftype)
23370 
      iprot.readFieldEnd()
23371 
    iprot.readStructEnd()
23372 
 
23373 
  def write(self, oprot):
23374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23376 
      return
23377 
    oprot.writeStructBegin('getSnapdealItems_args')
23378 
    if self.offset is not None:
23379 
      oprot.writeFieldBegin('offset', TType.I64, 1)
23380 
      oprot.writeI64(self.offset)
23381 
      oprot.writeFieldEnd()
23382 
    if self.limit is not None:
23383 
      oprot.writeFieldBegin('limit', TType.I64, 2)
23384 
      oprot.writeI64(self.limit)
23385 
      oprot.writeFieldEnd()
23386 
    oprot.writeFieldStop()
23387 
    oprot.writeStructEnd()
23388 
 
23389 
  def validate(self):
23390 
    return
23391 
 
23392 
 
23393 
  def __repr__(self):
23394 
    L = ['%s=%r' % (key, value)
23395 
      for key, value in self.__dict__.iteritems()]
23396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23397 
 
23398 
  def __eq__(self, other):
23399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23400 
 
23401 
  def __ne__(self, other):
23402 
    return not (self == other)
23403 
 
23404 
class getSnapdealItems_result:
23405 
  """
23406 
  Attributes:
23407 
   - success
23408 
  """
23409 
 
23410 
  thrift_spec = (
23411 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23412 
  )
23413 
 
23414 
  def __init__(self, success=None,):
23415 
    self.success = success
23416 
 
23417 
  def read(self, iprot):
23418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23420 
      return
23421 
    iprot.readStructBegin()
23422 
    while True:
23423 
      (fname, ftype, fid) = iprot.readFieldBegin()
23424 
      if ftype == TType.STOP:
23425 
        break
23426 
      if fid == 0:
23427 
        if ftype == TType.LIST:
23428 
          self.success = []
9155 kshitij.so 23429 
          (_etype523, _size520) = iprot.readListBegin()
23430 
          for _i524 in xrange(_size520):
9242 kshitij.so 23431 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 23432 
            _elem525.read(iprot)
23433 
            self.success.append(_elem525)
8739 vikram.rag 23434 
          iprot.readListEnd()
23435 
        else:
23436 
          iprot.skip(ftype)
23437 
      else:
23438 
        iprot.skip(ftype)
23439 
      iprot.readFieldEnd()
23440 
    iprot.readStructEnd()
23441 
 
23442 
  def write(self, oprot):
23443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23445 
      return
9242 kshitij.so 23446 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 23447 
    if self.success is not None:
23448 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23449 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23450 
      for iter526 in self.success:
23451 
        iter526.write(oprot)
8739 vikram.rag 23452 
      oprot.writeListEnd()
23453 
      oprot.writeFieldEnd()
23454 
    oprot.writeFieldStop()
23455 
    oprot.writeStructEnd()
23456 
 
23457 
  def validate(self):
23458 
    return
23459 
 
23460 
 
23461 
  def __repr__(self):
23462 
    L = ['%s=%r' % (key, value)
23463 
      for key, value in self.__dict__.iteritems()]
23464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23465 
 
23466 
  def __eq__(self, other):
23467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23468 
 
23469 
  def __ne__(self, other):
23470 
    return not (self == other)
9242 kshitij.so 23471 
 
23472 
class searchSnapdealItems_args:
23473 
  """
23474 
  Attributes:
23475 
   - searchTerm
23476 
   - offset
23477 
   - limit
23478 
  """
23479 
 
23480 
  thrift_spec = (
23481 
    None, # 0
23482 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23483 
    (2, TType.I64, 'offset', None, None, ), # 2
23484 
    (3, TType.I64, 'limit', None, None, ), # 3
23485 
  )
23486 
 
23487 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
23488 
    self.searchTerm = searchTerm
23489 
    self.offset = offset
23490 
    self.limit = limit
23491 
 
23492 
  def read(self, iprot):
23493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23495 
      return
23496 
    iprot.readStructBegin()
23497 
    while True:
23498 
      (fname, ftype, fid) = iprot.readFieldBegin()
23499 
      if ftype == TType.STOP:
23500 
        break
23501 
      if fid == 1:
23502 
        if ftype == TType.LIST:
23503 
          self.searchTerm = []
23504 
          (_etype530, _size527) = iprot.readListBegin()
23505 
          for _i531 in xrange(_size527):
23506 
            _elem532 = iprot.readString();
23507 
            self.searchTerm.append(_elem532)
23508 
          iprot.readListEnd()
23509 
        else:
23510 
          iprot.skip(ftype)
23511 
      elif fid == 2:
23512 
        if ftype == TType.I64:
23513 
          self.offset = iprot.readI64();
23514 
        else:
23515 
          iprot.skip(ftype)
23516 
      elif fid == 3:
23517 
        if ftype == TType.I64:
23518 
          self.limit = iprot.readI64();
23519 
        else:
23520 
          iprot.skip(ftype)
23521 
      else:
23522 
        iprot.skip(ftype)
23523 
      iprot.readFieldEnd()
23524 
    iprot.readStructEnd()
23525 
 
23526 
  def write(self, oprot):
23527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23529 
      return
23530 
    oprot.writeStructBegin('searchSnapdealItems_args')
23531 
    if self.searchTerm is not None:
23532 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23533 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23534 
      for iter533 in self.searchTerm:
23535 
        oprot.writeString(iter533)
23536 
      oprot.writeListEnd()
23537 
      oprot.writeFieldEnd()
23538 
    if self.offset is not None:
23539 
      oprot.writeFieldBegin('offset', TType.I64, 2)
23540 
      oprot.writeI64(self.offset)
23541 
      oprot.writeFieldEnd()
23542 
    if self.limit is not None:
23543 
      oprot.writeFieldBegin('limit', TType.I64, 3)
23544 
      oprot.writeI64(self.limit)
23545 
      oprot.writeFieldEnd()
23546 
    oprot.writeFieldStop()
23547 
    oprot.writeStructEnd()
23548 
 
23549 
  def validate(self):
23550 
    return
23551 
 
23552 
 
23553 
  def __repr__(self):
23554 
    L = ['%s=%r' % (key, value)
23555 
      for key, value in self.__dict__.iteritems()]
23556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23557 
 
23558 
  def __eq__(self, other):
23559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23560 
 
23561 
  def __ne__(self, other):
23562 
    return not (self == other)
23563 
 
23564 
class searchSnapdealItems_result:
23565 
  """
23566 
  Attributes:
23567 
   - success
23568 
  """
23569 
 
23570 
  thrift_spec = (
23571 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23572 
  )
23573 
 
23574 
  def __init__(self, success=None,):
23575 
    self.success = success
23576 
 
23577 
  def read(self, iprot):
23578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23580 
      return
23581 
    iprot.readStructBegin()
23582 
    while True:
23583 
      (fname, ftype, fid) = iprot.readFieldBegin()
23584 
      if ftype == TType.STOP:
23585 
        break
23586 
      if fid == 0:
23587 
        if ftype == TType.LIST:
23588 
          self.success = []
23589 
          (_etype537, _size534) = iprot.readListBegin()
23590 
          for _i538 in xrange(_size534):
23591 
            _elem539 = SnapdealItemDetails()
23592 
            _elem539.read(iprot)
23593 
            self.success.append(_elem539)
23594 
          iprot.readListEnd()
23595 
        else:
23596 
          iprot.skip(ftype)
23597 
      else:
23598 
        iprot.skip(ftype)
23599 
      iprot.readFieldEnd()
23600 
    iprot.readStructEnd()
23601 
 
23602 
  def write(self, oprot):
23603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23605 
      return
23606 
    oprot.writeStructBegin('searchSnapdealItems_result')
23607 
    if self.success is not None:
23608 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23609 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23610 
      for iter540 in self.success:
23611 
        iter540.write(oprot)
23612 
      oprot.writeListEnd()
23613 
      oprot.writeFieldEnd()
23614 
    oprot.writeFieldStop()
23615 
    oprot.writeStructEnd()
23616 
 
23617 
  def validate(self):
23618 
    return
23619 
 
23620 
 
23621 
  def __repr__(self):
23622 
    L = ['%s=%r' % (key, value)
23623 
      for key, value in self.__dict__.iteritems()]
23624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23625 
 
23626 
  def __eq__(self, other):
23627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23628 
 
23629 
  def __ne__(self, other):
23630 
    return not (self == other)
23631 
 
23632 
class getCountForSnapdealItems_args:
23633 
 
23634 
  thrift_spec = (
23635 
  )
23636 
 
23637 
  def read(self, iprot):
23638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23640 
      return
23641 
    iprot.readStructBegin()
23642 
    while True:
23643 
      (fname, ftype, fid) = iprot.readFieldBegin()
23644 
      if ftype == TType.STOP:
23645 
        break
23646 
      else:
23647 
        iprot.skip(ftype)
23648 
      iprot.readFieldEnd()
23649 
    iprot.readStructEnd()
23650 
 
23651 
  def write(self, oprot):
23652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23654 
      return
23655 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
23656 
    oprot.writeFieldStop()
23657 
    oprot.writeStructEnd()
23658 
 
23659 
  def validate(self):
23660 
    return
23661 
 
23662 
 
23663 
  def __repr__(self):
23664 
    L = ['%s=%r' % (key, value)
23665 
      for key, value in self.__dict__.iteritems()]
23666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23667 
 
23668 
  def __eq__(self, other):
23669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23670 
 
23671 
  def __ne__(self, other):
23672 
    return not (self == other)
23673 
 
23674 
class getCountForSnapdealItems_result:
23675 
  """
23676 
  Attributes:
23677 
   - success
23678 
  """
23679 
 
23680 
  thrift_spec = (
23681 
    (0, TType.I64, 'success', None, None, ), # 0
23682 
  )
23683 
 
23684 
  def __init__(self, success=None,):
23685 
    self.success = success
23686 
 
23687 
  def read(self, iprot):
23688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23690 
      return
23691 
    iprot.readStructBegin()
23692 
    while True:
23693 
      (fname, ftype, fid) = iprot.readFieldBegin()
23694 
      if ftype == TType.STOP:
23695 
        break
23696 
      if fid == 0:
23697 
        if ftype == TType.I64:
23698 
          self.success = iprot.readI64();
23699 
        else:
23700 
          iprot.skip(ftype)
23701 
      else:
23702 
        iprot.skip(ftype)
23703 
      iprot.readFieldEnd()
23704 
    iprot.readStructEnd()
23705 
 
23706 
  def write(self, oprot):
23707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23709 
      return
23710 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
23711 
    if self.success is not None:
23712 
      oprot.writeFieldBegin('success', TType.I64, 0)
23713 
      oprot.writeI64(self.success)
23714 
      oprot.writeFieldEnd()
23715 
    oprot.writeFieldStop()
23716 
    oprot.writeStructEnd()
23717 
 
23718 
  def validate(self):
23719 
    return
23720 
 
23721 
 
23722 
  def __repr__(self):
23723 
    L = ['%s=%r' % (key, value)
23724 
      for key, value in self.__dict__.iteritems()]
23725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23726 
 
23727 
  def __eq__(self, other):
23728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23729 
 
23730 
  def __ne__(self, other):
23731 
    return not (self == other)
23732 
 
23733 
class getSnapdealSearchResultCount_args:
23734 
  """
23735 
  Attributes:
23736 
   - searchTerm
23737 
  """
23738 
 
23739 
  thrift_spec = (
23740 
    None, # 0
23741 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23742 
  )
23743 
 
23744 
  def __init__(self, searchTerm=None,):
23745 
    self.searchTerm = searchTerm
23746 
 
23747 
  def read(self, iprot):
23748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23750 
      return
23751 
    iprot.readStructBegin()
23752 
    while True:
23753 
      (fname, ftype, fid) = iprot.readFieldBegin()
23754 
      if ftype == TType.STOP:
23755 
        break
23756 
      if fid == 1:
23757 
        if ftype == TType.LIST:
23758 
          self.searchTerm = []
23759 
          (_etype544, _size541) = iprot.readListBegin()
23760 
          for _i545 in xrange(_size541):
23761 
            _elem546 = iprot.readString();
23762 
            self.searchTerm.append(_elem546)
23763 
          iprot.readListEnd()
23764 
        else:
23765 
          iprot.skip(ftype)
23766 
      else:
23767 
        iprot.skip(ftype)
23768 
      iprot.readFieldEnd()
23769 
    iprot.readStructEnd()
23770 
 
23771 
  def write(self, oprot):
23772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23774 
      return
23775 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
23776 
    if self.searchTerm is not None:
23777 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23778 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23779 
      for iter547 in self.searchTerm:
23780 
        oprot.writeString(iter547)
23781 
      oprot.writeListEnd()
23782 
      oprot.writeFieldEnd()
23783 
    oprot.writeFieldStop()
23784 
    oprot.writeStructEnd()
23785 
 
23786 
  def validate(self):
23787 
    return
23788 
 
23789 
 
23790 
  def __repr__(self):
23791 
    L = ['%s=%r' % (key, value)
23792 
      for key, value in self.__dict__.iteritems()]
23793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23794 
 
23795 
  def __eq__(self, other):
23796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23797 
 
23798 
  def __ne__(self, other):
23799 
    return not (self == other)
23800 
 
23801 
class getSnapdealSearchResultCount_result:
23802 
  """
23803 
  Attributes:
23804 
   - success
23805 
  """
23806 
 
23807 
  thrift_spec = (
23808 
    (0, TType.I64, 'success', None, None, ), # 0
23809 
  )
23810 
 
23811 
  def __init__(self, success=None,):
23812 
    self.success = success
23813 
 
23814 
  def read(self, iprot):
23815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23817 
      return
23818 
    iprot.readStructBegin()
23819 
    while True:
23820 
      (fname, ftype, fid) = iprot.readFieldBegin()
23821 
      if ftype == TType.STOP:
23822 
        break
23823 
      if fid == 0:
23824 
        if ftype == TType.I64:
23825 
          self.success = iprot.readI64();
23826 
        else:
23827 
          iprot.skip(ftype)
23828 
      else:
23829 
        iprot.skip(ftype)
23830 
      iprot.readFieldEnd()
23831 
    iprot.readStructEnd()
23832 
 
23833 
  def write(self, oprot):
23834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23836 
      return
23837 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
23838 
    if self.success is not None:
23839 
      oprot.writeFieldBegin('success', TType.I64, 0)
23840 
      oprot.writeI64(self.success)
23841 
      oprot.writeFieldEnd()
23842 
    oprot.writeFieldStop()
23843 
    oprot.writeStructEnd()
23844 
 
23845 
  def validate(self):
23846 
    return
23847 
 
23848 
 
23849 
  def __repr__(self):
23850 
    L = ['%s=%r' % (key, value)
23851 
      for key, value in self.__dict__.iteritems()]
23852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23853 
 
23854 
  def __eq__(self, other):
23855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23856 
 
23857 
  def __ne__(self, other):
23858 
    return not (self == other)
9299 kshitij.so 23859 
 
23860 
class getPrefferedInsurerForItem_args:
23861 
  """
23862 
  Attributes:
23863 
   - itemId
23864 
   - insurerType
23865 
  """
23866 
 
23867 
  thrift_spec = (
23868 
    None, # 0
23869 
    (1, TType.I64, 'itemId', None, None, ), # 1
23870 
    (2, TType.I32, 'insurerType', None, None, ), # 2
23871 
  )
23872 
 
23873 
  def __init__(self, itemId=None, insurerType=None,):
23874 
    self.itemId = itemId
23875 
    self.insurerType = insurerType
23876 
 
23877 
  def read(self, iprot):
23878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23880 
      return
23881 
    iprot.readStructBegin()
23882 
    while True:
23883 
      (fname, ftype, fid) = iprot.readFieldBegin()
23884 
      if ftype == TType.STOP:
23885 
        break
23886 
      if fid == 1:
23887 
        if ftype == TType.I64:
23888 
          self.itemId = iprot.readI64();
23889 
        else:
23890 
          iprot.skip(ftype)
23891 
      elif fid == 2:
23892 
        if ftype == TType.I32:
23893 
          self.insurerType = iprot.readI32();
23894 
        else:
23895 
          iprot.skip(ftype)
23896 
      else:
23897 
        iprot.skip(ftype)
23898 
      iprot.readFieldEnd()
23899 
    iprot.readStructEnd()
23900 
 
23901 
  def write(self, oprot):
23902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23904 
      return
23905 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
23906 
    if self.itemId is not None:
23907 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
23908 
      oprot.writeI64(self.itemId)
23909 
      oprot.writeFieldEnd()
23910 
    if self.insurerType is not None:
23911 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
23912 
      oprot.writeI32(self.insurerType)
23913 
      oprot.writeFieldEnd()
23914 
    oprot.writeFieldStop()
23915 
    oprot.writeStructEnd()
23916 
 
23917 
  def validate(self):
23918 
    return
23919 
 
23920 
 
23921 
  def __repr__(self):
23922 
    L = ['%s=%r' % (key, value)
23923 
      for key, value in self.__dict__.iteritems()]
23924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23925 
 
23926 
  def __eq__(self, other):
23927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23928 
 
23929 
  def __ne__(self, other):
23930 
    return not (self == other)
23931 
 
23932 
class getPrefferedInsurerForItem_result:
23933 
  """
23934 
  Attributes:
23935 
   - success
23936 
  """
23937 
 
23938 
  thrift_spec = (
23939 
    (0, TType.I64, 'success', None, None, ), # 0
23940 
  )
23941 
 
23942 
  def __init__(self, success=None,):
23943 
    self.success = success
23944 
 
23945 
  def read(self, iprot):
23946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23948 
      return
23949 
    iprot.readStructBegin()
23950 
    while True:
23951 
      (fname, ftype, fid) = iprot.readFieldBegin()
23952 
      if ftype == TType.STOP:
23953 
        break
23954 
      if fid == 0:
23955 
        if ftype == TType.I64:
23956 
          self.success = iprot.readI64();
23957 
        else:
23958 
          iprot.skip(ftype)
23959 
      else:
23960 
        iprot.skip(ftype)
23961 
      iprot.readFieldEnd()
23962 
    iprot.readStructEnd()
23963 
 
23964 
  def write(self, oprot):
23965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23967 
      return
23968 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
23969 
    if self.success is not None:
23970 
      oprot.writeFieldBegin('success', TType.I64, 0)
23971 
      oprot.writeI64(self.success)
23972 
      oprot.writeFieldEnd()
23973 
    oprot.writeFieldStop()
23974 
    oprot.writeStructEnd()
23975 
 
23976 
  def validate(self):
23977 
    return
23978 
 
23979 
 
23980 
  def __repr__(self):
23981 
    L = ['%s=%r' % (key, value)
23982 
      for key, value in self.__dict__.iteritems()]
23983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23984 
 
23985 
  def __eq__(self, other):
23986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23987 
 
23988 
  def __ne__(self, other):
23989 
    return not (self == other)
9456 vikram.rag 23990 
 
23991 
class getSnapdealItembySkuAtSnapdeal_args:
23992 
  """
23993 
  Attributes:
23994 
   - skuAtSnapdeal
23995 
  """
23996 
 
23997 
  thrift_spec = None
23998 
  def __init__(self, skuAtSnapdeal=None,):
23999 
    self.skuAtSnapdeal = skuAtSnapdeal
24000 
 
24001 
  def read(self, iprot):
24002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24004 
      return
24005 
    iprot.readStructBegin()
24006 
    while True:
24007 
      (fname, ftype, fid) = iprot.readFieldBegin()
24008 
      if ftype == TType.STOP:
24009 
        break
24010 
      if fid == -1:
24011 
        if ftype == TType.STRING:
24012 
          self.skuAtSnapdeal = iprot.readString();
24013 
        else:
24014 
          iprot.skip(ftype)
24015 
      else:
24016 
        iprot.skip(ftype)
24017 
      iprot.readFieldEnd()
24018 
    iprot.readStructEnd()
24019 
 
24020 
  def write(self, oprot):
24021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24023 
      return
24024 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
24025 
    if self.skuAtSnapdeal is not None:
24026 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
24027 
      oprot.writeString(self.skuAtSnapdeal)
24028 
      oprot.writeFieldEnd()
24029 
    oprot.writeFieldStop()
24030 
    oprot.writeStructEnd()
24031 
 
24032 
  def validate(self):
24033 
    return
24034 
 
24035 
 
24036 
  def __repr__(self):
24037 
    L = ['%s=%r' % (key, value)
24038 
      for key, value in self.__dict__.iteritems()]
24039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24040 
 
24041 
  def __eq__(self, other):
24042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24043 
 
24044 
  def __ne__(self, other):
24045 
    return not (self == other)
24046 
 
24047 
class getSnapdealItembySkuAtSnapdeal_result:
24048 
  """
24049 
  Attributes:
24050 
   - success
24051 
  """
24052 
 
24053 
  thrift_spec = (
24054 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
24055 
  )
24056 
 
24057 
  def __init__(self, success=None,):
24058 
    self.success = success
24059 
 
24060 
  def read(self, iprot):
24061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24063 
      return
24064 
    iprot.readStructBegin()
24065 
    while True:
24066 
      (fname, ftype, fid) = iprot.readFieldBegin()
24067 
      if ftype == TType.STOP:
24068 
        break
24069 
      if fid == 0:
24070 
        if ftype == TType.STRUCT:
24071 
          self.success = SnapdealItem()
24072 
          self.success.read(iprot)
24073 
        else:
24074 
          iprot.skip(ftype)
24075 
      else:
24076 
        iprot.skip(ftype)
24077 
      iprot.readFieldEnd()
24078 
    iprot.readStructEnd()
24079 
 
24080 
  def write(self, oprot):
24081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24083 
      return
24084 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
24085 
    if self.success is not None:
24086 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24087 
      self.success.write(oprot)
24088 
      oprot.writeFieldEnd()
24089 
    oprot.writeFieldStop()
24090 
    oprot.writeStructEnd()
24091 
 
24092 
  def validate(self):
24093 
    return
24094 
 
24095 
 
24096 
  def __repr__(self):
24097 
    L = ['%s=%r' % (key, value)
24098 
      for key, value in self.__dict__.iteritems()]
24099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24100 
 
24101 
  def __eq__(self, other):
24102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24103 
 
24104 
  def __ne__(self, other):
24105 
    return not (self == other)
9621 manish.sha 24106 
 
24107 
class getProductFeedSubmit_args:
24108 
  """
24109 
  Attributes:
24110 
   - catalogItemId
24111 
  """
24112 
 
24113 
  thrift_spec = (
24114 
    None, # 0
24115 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24116 
  )
24117 
 
24118 
  def __init__(self, catalogItemId=None,):
24119 
    self.catalogItemId = catalogItemId
24120 
 
24121 
  def read(self, iprot):
24122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24124 
      return
24125 
    iprot.readStructBegin()
24126 
    while True:
24127 
      (fname, ftype, fid) = iprot.readFieldBegin()
24128 
      if ftype == TType.STOP:
24129 
        break
24130 
      if fid == 1:
24131 
        if ftype == TType.I64:
24132 
          self.catalogItemId = iprot.readI64();
24133 
        else:
24134 
          iprot.skip(ftype)
24135 
      else:
24136 
        iprot.skip(ftype)
24137 
      iprot.readFieldEnd()
24138 
    iprot.readStructEnd()
24139 
 
24140 
  def write(self, oprot):
24141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24143 
      return
24144 
    oprot.writeStructBegin('getProductFeedSubmit_args')
24145 
    if self.catalogItemId is not None:
24146 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24147 
      oprot.writeI64(self.catalogItemId)
24148 
      oprot.writeFieldEnd()
24149 
    oprot.writeFieldStop()
24150 
    oprot.writeStructEnd()
24151 
 
24152 
  def validate(self):
24153 
    return
24154 
 
24155 
 
24156 
  def __repr__(self):
24157 
    L = ['%s=%r' % (key, value)
24158 
      for key, value in self.__dict__.iteritems()]
24159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24160 
 
24161 
  def __eq__(self, other):
24162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24163 
 
24164 
  def __ne__(self, other):
24165 
    return not (self == other)
24166 
 
24167 
class getProductFeedSubmit_result:
24168 
  """
24169 
  Attributes:
24170 
   - success
24171 
   - cex
24172 
  """
24173 
 
24174 
  thrift_spec = (
24175 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
24176 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24177 
  )
24178 
 
24179 
  def __init__(self, success=None, cex=None,):
24180 
    self.success = success
24181 
    self.cex = cex
24182 
 
24183 
  def read(self, iprot):
24184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24186 
      return
24187 
    iprot.readStructBegin()
24188 
    while True:
24189 
      (fname, ftype, fid) = iprot.readFieldBegin()
24190 
      if ftype == TType.STOP:
24191 
        break
24192 
      if fid == 0:
24193 
        if ftype == TType.STRUCT:
24194 
          self.success = ProductFeedSubmit()
24195 
          self.success.read(iprot)
24196 
        else:
24197 
          iprot.skip(ftype)
24198 
      elif fid == 1:
24199 
        if ftype == TType.STRUCT:
24200 
          self.cex = CatalogServiceException()
24201 
          self.cex.read(iprot)
24202 
        else:
24203 
          iprot.skip(ftype)
24204 
      else:
24205 
        iprot.skip(ftype)
24206 
      iprot.readFieldEnd()
24207 
    iprot.readStructEnd()
24208 
 
24209 
  def write(self, oprot):
24210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24212 
      return
24213 
    oprot.writeStructBegin('getProductFeedSubmit_result')
24214 
    if self.success is not None:
24215 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24216 
      self.success.write(oprot)
24217 
      oprot.writeFieldEnd()
24218 
    if self.cex is not None:
24219 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24220 
      self.cex.write(oprot)
24221 
      oprot.writeFieldEnd()
24222 
    oprot.writeFieldStop()
24223 
    oprot.writeStructEnd()
24224 
 
24225 
  def validate(self):
24226 
    return
24227 
 
24228 
 
24229 
  def __repr__(self):
24230 
    L = ['%s=%r' % (key, value)
24231 
      for key, value in self.__dict__.iteritems()]
24232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24233 
 
24234 
  def __eq__(self, other):
24235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24236 
 
24237 
  def __ne__(self, other):
24238 
    return not (self == other)
24239 
 
24240 
class addProductFeedSubmit_args:
24241 
  """
24242 
  Attributes:
24243 
   - productFeedSubmit
24244 
  """
24245 
 
24246 
  thrift_spec = (
24247 
    None, # 0
24248 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24249 
  )
24250 
 
24251 
  def __init__(self, productFeedSubmit=None,):
24252 
    self.productFeedSubmit = productFeedSubmit
24253 
 
24254 
  def read(self, iprot):
24255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24257 
      return
24258 
    iprot.readStructBegin()
24259 
    while True:
24260 
      (fname, ftype, fid) = iprot.readFieldBegin()
24261 
      if ftype == TType.STOP:
24262 
        break
24263 
      if fid == 1:
24264 
        if ftype == TType.STRUCT:
24265 
          self.productFeedSubmit = ProductFeedSubmit()
24266 
          self.productFeedSubmit.read(iprot)
24267 
        else:
24268 
          iprot.skip(ftype)
24269 
      else:
24270 
        iprot.skip(ftype)
24271 
      iprot.readFieldEnd()
24272 
    iprot.readStructEnd()
24273 
 
24274 
  def write(self, oprot):
24275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24277 
      return
24278 
    oprot.writeStructBegin('addProductFeedSubmit_args')
24279 
    if self.productFeedSubmit is not None:
24280 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24281 
      self.productFeedSubmit.write(oprot)
24282 
      oprot.writeFieldEnd()
24283 
    oprot.writeFieldStop()
24284 
    oprot.writeStructEnd()
24285 
 
24286 
  def validate(self):
24287 
    return
24288 
 
24289 
 
24290 
  def __repr__(self):
24291 
    L = ['%s=%r' % (key, value)
24292 
      for key, value in self.__dict__.iteritems()]
24293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24294 
 
24295 
  def __eq__(self, other):
24296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24297 
 
24298 
  def __ne__(self, other):
24299 
    return not (self == other)
24300 
 
24301 
class addProductFeedSubmit_result:
24302 
  """
24303 
  Attributes:
24304 
   - success
24305 
   - cex
24306 
  """
24307 
 
24308 
  thrift_spec = (
24309 
    (0, TType.BOOL, 'success', None, None, ), # 0
24310 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24311 
  )
24312 
 
24313 
  def __init__(self, success=None, cex=None,):
24314 
    self.success = success
24315 
    self.cex = cex
24316 
 
24317 
  def read(self, iprot):
24318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24320 
      return
24321 
    iprot.readStructBegin()
24322 
    while True:
24323 
      (fname, ftype, fid) = iprot.readFieldBegin()
24324 
      if ftype == TType.STOP:
24325 
        break
24326 
      if fid == 0:
24327 
        if ftype == TType.BOOL:
24328 
          self.success = iprot.readBool();
24329 
        else:
24330 
          iprot.skip(ftype)
24331 
      elif fid == 1:
24332 
        if ftype == TType.STRUCT:
24333 
          self.cex = CatalogServiceException()
24334 
          self.cex.read(iprot)
24335 
        else:
24336 
          iprot.skip(ftype)
24337 
      else:
24338 
        iprot.skip(ftype)
24339 
      iprot.readFieldEnd()
24340 
    iprot.readStructEnd()
24341 
 
24342 
  def write(self, oprot):
24343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24345 
      return
24346 
    oprot.writeStructBegin('addProductFeedSubmit_result')
24347 
    if self.success is not None:
24348 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24349 
      oprot.writeBool(self.success)
24350 
      oprot.writeFieldEnd()
24351 
    if self.cex is not None:
24352 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24353 
      self.cex.write(oprot)
24354 
      oprot.writeFieldEnd()
24355 
    oprot.writeFieldStop()
24356 
    oprot.writeStructEnd()
24357 
 
24358 
  def validate(self):
24359 
    return
24360 
 
24361 
 
24362 
  def __repr__(self):
24363 
    L = ['%s=%r' % (key, value)
24364 
      for key, value in self.__dict__.iteritems()]
24365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24366 
 
24367 
  def __eq__(self, other):
24368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24369 
 
24370 
  def __ne__(self, other):
24371 
    return not (self == other)
24372 
 
24373 
class updateProductFeedSubmit_args:
24374 
  """
24375 
  Attributes:
24376 
   - productFeedSubmit
24377 
  """
24378 
 
24379 
  thrift_spec = (
24380 
    None, # 0
24381 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24382 
  )
24383 
 
24384 
  def __init__(self, productFeedSubmit=None,):
24385 
    self.productFeedSubmit = productFeedSubmit
24386 
 
24387 
  def read(self, iprot):
24388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24390 
      return
24391 
    iprot.readStructBegin()
24392 
    while True:
24393 
      (fname, ftype, fid) = iprot.readFieldBegin()
24394 
      if ftype == TType.STOP:
24395 
        break
24396 
      if fid == 1:
24397 
        if ftype == TType.STRUCT:
24398 
          self.productFeedSubmit = ProductFeedSubmit()
24399 
          self.productFeedSubmit.read(iprot)
24400 
        else:
24401 
          iprot.skip(ftype)
24402 
      else:
24403 
        iprot.skip(ftype)
24404 
      iprot.readFieldEnd()
24405 
    iprot.readStructEnd()
24406 
 
24407 
  def write(self, oprot):
24408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24410 
      return
24411 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
24412 
    if self.productFeedSubmit is not None:
24413 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24414 
      self.productFeedSubmit.write(oprot)
24415 
      oprot.writeFieldEnd()
24416 
    oprot.writeFieldStop()
24417 
    oprot.writeStructEnd()
24418 
 
24419 
  def validate(self):
24420 
    return
24421 
 
24422 
 
24423 
  def __repr__(self):
24424 
    L = ['%s=%r' % (key, value)
24425 
      for key, value in self.__dict__.iteritems()]
24426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24427 
 
24428 
  def __eq__(self, other):
24429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24430 
 
24431 
  def __ne__(self, other):
24432 
    return not (self == other)
24433 
 
24434 
class updateProductFeedSubmit_result:
24435 
  """
24436 
  Attributes:
24437 
   - success
24438 
   - cex
24439 
  """
24440 
 
24441 
  thrift_spec = (
24442 
    (0, TType.BOOL, 'success', None, None, ), # 0
24443 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24444 
  )
24445 
 
24446 
  def __init__(self, success=None, cex=None,):
24447 
    self.success = success
24448 
    self.cex = cex
24449 
 
24450 
  def read(self, iprot):
24451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24453 
      return
24454 
    iprot.readStructBegin()
24455 
    while True:
24456 
      (fname, ftype, fid) = iprot.readFieldBegin()
24457 
      if ftype == TType.STOP:
24458 
        break
24459 
      if fid == 0:
24460 
        if ftype == TType.BOOL:
24461 
          self.success = iprot.readBool();
24462 
        else:
24463 
          iprot.skip(ftype)
24464 
      elif fid == 1:
24465 
        if ftype == TType.STRUCT:
24466 
          self.cex = CatalogServiceException()
24467 
          self.cex.read(iprot)
24468 
        else:
24469 
          iprot.skip(ftype)
24470 
      else:
24471 
        iprot.skip(ftype)
24472 
      iprot.readFieldEnd()
24473 
    iprot.readStructEnd()
24474 
 
24475 
  def write(self, oprot):
24476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24478 
      return
24479 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
24480 
    if self.success is not None:
24481 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24482 
      oprot.writeBool(self.success)
24483 
      oprot.writeFieldEnd()
24484 
    if self.cex is not None:
24485 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24486 
      self.cex.write(oprot)
24487 
      oprot.writeFieldEnd()
24488 
    oprot.writeFieldStop()
24489 
    oprot.writeStructEnd()
24490 
 
24491 
  def validate(self):
24492 
    return
24493 
 
24494 
 
24495 
  def __repr__(self):
24496 
    L = ['%s=%r' % (key, value)
24497 
      for key, value in self.__dict__.iteritems()]
24498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24499 
 
24500 
  def __eq__(self, other):
24501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24502 
 
24503 
  def __ne__(self, other):
24504 
    return not (self == other)
24505 
 
24506 
class deleteProductFeedSubmit_args:
24507 
  """
24508 
  Attributes:
24509 
   - catalogItemId
24510 
  """
24511 
 
24512 
  thrift_spec = (
24513 
    None, # 0
24514 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24515 
  )
24516 
 
24517 
  def __init__(self, catalogItemId=None,):
24518 
    self.catalogItemId = catalogItemId
24519 
 
24520 
  def read(self, iprot):
24521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24523 
      return
24524 
    iprot.readStructBegin()
24525 
    while True:
24526 
      (fname, ftype, fid) = iprot.readFieldBegin()
24527 
      if ftype == TType.STOP:
24528 
        break
24529 
      if fid == 1:
24530 
        if ftype == TType.I64:
24531 
          self.catalogItemId = iprot.readI64();
24532 
        else:
24533 
          iprot.skip(ftype)
24534 
      else:
24535 
        iprot.skip(ftype)
24536 
      iprot.readFieldEnd()
24537 
    iprot.readStructEnd()
24538 
 
24539 
  def write(self, oprot):
24540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24542 
      return
24543 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
24544 
    if self.catalogItemId is not None:
24545 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24546 
      oprot.writeI64(self.catalogItemId)
24547 
      oprot.writeFieldEnd()
24548 
    oprot.writeFieldStop()
24549 
    oprot.writeStructEnd()
24550 
 
24551 
  def validate(self):
24552 
    return
24553 
 
24554 
 
24555 
  def __repr__(self):
24556 
    L = ['%s=%r' % (key, value)
24557 
      for key, value in self.__dict__.iteritems()]
24558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24559 
 
24560 
  def __eq__(self, other):
24561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24562 
 
24563 
  def __ne__(self, other):
24564 
    return not (self == other)
24565 
 
24566 
class deleteProductFeedSubmit_result:
24567 
  """
24568 
  Attributes:
24569 
   - success
24570 
   - cex
24571 
  """
24572 
 
24573 
  thrift_spec = (
24574 
    (0, TType.BOOL, 'success', None, None, ), # 0
24575 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24576 
  )
24577 
 
24578 
  def __init__(self, success=None, cex=None,):
24579 
    self.success = success
24580 
    self.cex = cex
24581 
 
24582 
  def read(self, iprot):
24583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24585 
      return
24586 
    iprot.readStructBegin()
24587 
    while True:
24588 
      (fname, ftype, fid) = iprot.readFieldBegin()
24589 
      if ftype == TType.STOP:
24590 
        break
24591 
      if fid == 0:
24592 
        if ftype == TType.BOOL:
24593 
          self.success = iprot.readBool();
24594 
        else:
24595 
          iprot.skip(ftype)
24596 
      elif fid == 1:
24597 
        if ftype == TType.STRUCT:
24598 
          self.cex = CatalogServiceException()
24599 
          self.cex.read(iprot)
24600 
        else:
24601 
          iprot.skip(ftype)
24602 
      else:
24603 
        iprot.skip(ftype)
24604 
      iprot.readFieldEnd()
24605 
    iprot.readStructEnd()
24606 
 
24607 
  def write(self, oprot):
24608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24610 
      return
24611 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
24612 
    if self.success is not None:
24613 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24614 
      oprot.writeBool(self.success)
24615 
      oprot.writeFieldEnd()
24616 
    if self.cex is not None:
24617 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24618 
      self.cex.write(oprot)
24619 
      oprot.writeFieldEnd()
24620 
    oprot.writeFieldStop()
24621 
    oprot.writeStructEnd()
24622 
 
24623 
  def validate(self):
24624 
    return
24625 
 
24626 
 
24627 
  def __repr__(self):
24628 
    L = ['%s=%r' % (key, value)
24629 
      for key, value in self.__dict__.iteritems()]
24630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24631 
 
24632 
  def __eq__(self, other):
24633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24634 
 
24635 
  def __ne__(self, other):
24636 
    return not (self == other)
24637 
 
24638 
class getAllProductFeedSubmit_args:
24639 
 
24640 
  thrift_spec = (
24641 
  )
24642 
 
24643 
  def read(self, iprot):
24644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24646 
      return
24647 
    iprot.readStructBegin()
24648 
    while True:
24649 
      (fname, ftype, fid) = iprot.readFieldBegin()
24650 
      if ftype == TType.STOP:
24651 
        break
24652 
      else:
24653 
        iprot.skip(ftype)
24654 
      iprot.readFieldEnd()
24655 
    iprot.readStructEnd()
24656 
 
24657 
  def write(self, oprot):
24658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24660 
      return
24661 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
24662 
    oprot.writeFieldStop()
24663 
    oprot.writeStructEnd()
24664 
 
24665 
  def validate(self):
24666 
    return
24667 
 
24668 
 
24669 
  def __repr__(self):
24670 
    L = ['%s=%r' % (key, value)
24671 
      for key, value in self.__dict__.iteritems()]
24672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24673 
 
24674 
  def __eq__(self, other):
24675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24676 
 
24677 
  def __ne__(self, other):
24678 
    return not (self == other)
24679 
 
24680 
class getAllProductFeedSubmit_result:
24681 
  """
24682 
  Attributes:
24683 
   - success
24684 
   - cex
24685 
  """
24686 
 
24687 
  thrift_spec = (
24688 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
24689 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24690 
  )
24691 
 
24692 
  def __init__(self, success=None, cex=None,):
24693 
    self.success = success
24694 
    self.cex = cex
24695 
 
24696 
  def read(self, iprot):
24697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24699 
      return
24700 
    iprot.readStructBegin()
24701 
    while True:
24702 
      (fname, ftype, fid) = iprot.readFieldBegin()
24703 
      if ftype == TType.STOP:
24704 
        break
24705 
      if fid == 0:
24706 
        if ftype == TType.LIST:
24707 
          self.success = []
24708 
          (_etype551, _size548) = iprot.readListBegin()
24709 
          for _i552 in xrange(_size548):
24710 
            _elem553 = ProductFeedSubmit()
24711 
            _elem553.read(iprot)
24712 
            self.success.append(_elem553)
24713 
          iprot.readListEnd()
24714 
        else:
24715 
          iprot.skip(ftype)
24716 
      elif fid == 1:
24717 
        if ftype == TType.STRUCT:
24718 
          self.cex = CatalogServiceException()
24719 
          self.cex.read(iprot)
24720 
        else:
24721 
          iprot.skip(ftype)
24722 
      else:
24723 
        iprot.skip(ftype)
24724 
      iprot.readFieldEnd()
24725 
    iprot.readStructEnd()
24726 
 
24727 
  def write(self, oprot):
24728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24730 
      return
24731 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
24732 
    if self.success is not None:
24733 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24734 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24735 
      for iter554 in self.success:
24736 
        iter554.write(oprot)
24737 
      oprot.writeListEnd()
24738 
      oprot.writeFieldEnd()
24739 
    if self.cex is not None:
24740 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24741 
      self.cex.write(oprot)
24742 
      oprot.writeFieldEnd()
24743 
    oprot.writeFieldStop()
24744 
    oprot.writeStructEnd()
24745 
 
24746 
  def validate(self):
24747 
    return
24748 
 
24749 
 
24750 
  def __repr__(self):
24751 
    L = ['%s=%r' % (key, value)
24752 
      for key, value in self.__dict__.iteritems()]
24753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24754 
 
24755 
  def __eq__(self, other):
24756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24757 
 
24758 
  def __ne__(self, other):
24759 
    return not (self == other)
9724 kshitij.so 24760 
 
24761 
class getMarketplacedetailsForItem_args:
24762 
  """
24763 
  Attributes:
24764 
   - itemId
24765 
   - sourceId
24766 
  """
24767 
 
24768 
  thrift_spec = (
24769 
    None, # 0
24770 
    (1, TType.I64, 'itemId', None, None, ), # 1
24771 
    (2, TType.I64, 'sourceId', None, None, ), # 2
24772 
  )
24773 
 
24774 
  def __init__(self, itemId=None, sourceId=None,):
24775 
    self.itemId = itemId
24776 
    self.sourceId = sourceId
24777 
 
24778 
  def read(self, iprot):
24779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24781 
      return
24782 
    iprot.readStructBegin()
24783 
    while True:
24784 
      (fname, ftype, fid) = iprot.readFieldBegin()
24785 
      if ftype == TType.STOP:
24786 
        break
24787 
      if fid == 1:
24788 
        if ftype == TType.I64:
24789 
          self.itemId = iprot.readI64();
24790 
        else:
24791 
          iprot.skip(ftype)
24792 
      elif fid == 2:
24793 
        if ftype == TType.I64:
24794 
          self.sourceId = iprot.readI64();
24795 
        else:
24796 
          iprot.skip(ftype)
24797 
      else:
24798 
        iprot.skip(ftype)
24799 
      iprot.readFieldEnd()
24800 
    iprot.readStructEnd()
24801 
 
24802 
  def write(self, oprot):
24803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24805 
      return
24806 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
24807 
    if self.itemId is not None:
24808 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24809 
      oprot.writeI64(self.itemId)
24810 
      oprot.writeFieldEnd()
24811 
    if self.sourceId is not None:
24812 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
24813 
      oprot.writeI64(self.sourceId)
24814 
      oprot.writeFieldEnd()
24815 
    oprot.writeFieldStop()
24816 
    oprot.writeStructEnd()
24817 
 
24818 
  def validate(self):
24819 
    return
24820 
 
24821 
 
24822 
  def __repr__(self):
24823 
    L = ['%s=%r' % (key, value)
24824 
      for key, value in self.__dict__.iteritems()]
24825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24826 
 
24827 
  def __eq__(self, other):
24828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24829 
 
24830 
  def __ne__(self, other):
24831 
    return not (self == other)
24832 
 
24833 
class getMarketplacedetailsForItem_result:
24834 
  """
24835 
  Attributes:
24836 
   - success
24837 
  """
24838 
 
24839 
  thrift_spec = (
24840 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
24841 
  )
24842 
 
24843 
  def __init__(self, success=None,):
24844 
    self.success = success
24845 
 
24846 
  def read(self, iprot):
24847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24849 
      return
24850 
    iprot.readStructBegin()
24851 
    while True:
24852 
      (fname, ftype, fid) = iprot.readFieldBegin()
24853 
      if ftype == TType.STOP:
24854 
        break
24855 
      if fid == 0:
24856 
        if ftype == TType.STRUCT:
24857 
          self.success = MarketplaceItems()
24858 
          self.success.read(iprot)
24859 
        else:
24860 
          iprot.skip(ftype)
24861 
      else:
24862 
        iprot.skip(ftype)
24863 
      iprot.readFieldEnd()
24864 
    iprot.readStructEnd()
24865 
 
24866 
  def write(self, oprot):
24867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24869 
      return
24870 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
24871 
    if self.success is not None:
24872 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24873 
      self.success.write(oprot)
24874 
      oprot.writeFieldEnd()
24875 
    oprot.writeFieldStop()
24876 
    oprot.writeStructEnd()
24877 
 
24878 
  def validate(self):
24879 
    return
24880 
 
24881 
 
24882 
  def __repr__(self):
24883 
    L = ['%s=%r' % (key, value)
24884 
      for key, value in self.__dict__.iteritems()]
24885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24886 
 
24887 
  def __eq__(self, other):
24888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24889 
 
24890 
  def __ne__(self, other):
24891 
    return not (self == other)
24892 
 
24893 
class updateMarketplaceAttributesForItem_args:
24894 
  """
24895 
  Attributes:
24896 
   - marketPlaceItem
24897 
  """
24898 
 
24899 
  thrift_spec = (
24900 
    None, # 0
24901 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
24902 
  )
24903 
 
24904 
  def __init__(self, marketPlaceItem=None,):
24905 
    self.marketPlaceItem = marketPlaceItem
24906 
 
24907 
  def read(self, iprot):
24908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24910 
      return
24911 
    iprot.readStructBegin()
24912 
    while True:
24913 
      (fname, ftype, fid) = iprot.readFieldBegin()
24914 
      if ftype == TType.STOP:
24915 
        break
24916 
      if fid == 1:
24917 
        if ftype == TType.STRUCT:
24918 
          self.marketPlaceItem = MarketplaceItems()
24919 
          self.marketPlaceItem.read(iprot)
24920 
        else:
24921 
          iprot.skip(ftype)
24922 
      else:
24923 
        iprot.skip(ftype)
24924 
      iprot.readFieldEnd()
24925 
    iprot.readStructEnd()
24926 
 
24927 
  def write(self, oprot):
24928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24930 
      return
24931 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
24932 
    if self.marketPlaceItem is not None:
24933 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
24934 
      self.marketPlaceItem.write(oprot)
24935 
      oprot.writeFieldEnd()
24936 
    oprot.writeFieldStop()
24937 
    oprot.writeStructEnd()
24938 
 
24939 
  def validate(self):
24940 
    return
24941 
 
24942 
 
24943 
  def __repr__(self):
24944 
    L = ['%s=%r' % (key, value)
24945 
      for key, value in self.__dict__.iteritems()]
24946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24947 
 
24948 
  def __eq__(self, other):
24949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24950 
 
24951 
  def __ne__(self, other):
24952 
    return not (self == other)
24953 
 
24954 
class updateMarketplaceAttributesForItem_result:
24955 
  """
24956 
  Attributes:
24957 
   - success
24958 
  """
24959 
 
24960 
  thrift_spec = (
24961 
    (0, TType.BOOL, 'success', None, None, ), # 0
24962 
  )
24963 
 
24964 
  def __init__(self, success=None,):
24965 
    self.success = success
24966 
 
24967 
  def read(self, iprot):
24968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24970 
      return
24971 
    iprot.readStructBegin()
24972 
    while True:
24973 
      (fname, ftype, fid) = iprot.readFieldBegin()
24974 
      if ftype == TType.STOP:
24975 
        break
24976 
      if fid == 0:
24977 
        if ftype == TType.BOOL:
24978 
          self.success = iprot.readBool();
24979 
        else:
24980 
          iprot.skip(ftype)
24981 
      else:
24982 
        iprot.skip(ftype)
24983 
      iprot.readFieldEnd()
24984 
    iprot.readStructEnd()
24985 
 
24986 
  def write(self, oprot):
24987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24989 
      return
24990 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
24991 
    if self.success is not None:
24992 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24993 
      oprot.writeBool(self.success)
24994 
      oprot.writeFieldEnd()
24995 
    oprot.writeFieldStop()
24996 
    oprot.writeStructEnd()
24997 
 
24998 
  def validate(self):
24999 
    return
25000 
 
25001 
 
25002 
  def __repr__(self):
25003 
    L = ['%s=%r' % (key, value)
25004 
      for key, value in self.__dict__.iteritems()]
25005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25006 
 
25007 
  def __eq__(self, other):
25008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25009 
 
25010 
  def __ne__(self, other):
25011 
    return not (self == other)
9776 vikram.rag 25012 
 
9779 kshitij.so 25013 
class getCostingForMarketplace_args:
25014 
  """
25015 
  Attributes:
25016 
   - source
25017 
   - item_id
25018 
  """
25019 
 
25020 
  thrift_spec = (
25021 
    None, # 0
25022 
    (1, TType.I64, 'source', None, None, ), # 1
25023 
    (2, TType.I64, 'item_id', None, None, ), # 2
25024 
  )
25025 
 
25026 
  def __init__(self, source=None, item_id=None,):
25027 
    self.source = source
25028 
    self.item_id = item_id
25029 
 
25030 
  def read(self, iprot):
25031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25033 
      return
25034 
    iprot.readStructBegin()
25035 
    while True:
25036 
      (fname, ftype, fid) = iprot.readFieldBegin()
25037 
      if ftype == TType.STOP:
25038 
        break
25039 
      if fid == 1:
25040 
        if ftype == TType.I64:
25041 
          self.source = iprot.readI64();
25042 
        else:
25043 
          iprot.skip(ftype)
25044 
      elif fid == 2:
25045 
        if ftype == TType.I64:
25046 
          self.item_id = iprot.readI64();
25047 
        else:
25048 
          iprot.skip(ftype)
25049 
      else:
25050 
        iprot.skip(ftype)
25051 
      iprot.readFieldEnd()
25052 
    iprot.readStructEnd()
25053 
 
25054 
  def write(self, oprot):
25055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25057 
      return
25058 
    oprot.writeStructBegin('getCostingForMarketplace_args')
25059 
    if self.source is not None:
25060 
      oprot.writeFieldBegin('source', TType.I64, 1)
25061 
      oprot.writeI64(self.source)
25062 
      oprot.writeFieldEnd()
25063 
    if self.item_id is not None:
25064 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
25065 
      oprot.writeI64(self.item_id)
25066 
      oprot.writeFieldEnd()
25067 
    oprot.writeFieldStop()
25068 
    oprot.writeStructEnd()
25069 
 
25070 
  def validate(self):
25071 
    return
25072 
 
25073 
 
25074 
  def __repr__(self):
25075 
    L = ['%s=%r' % (key, value)
25076 
      for key, value in self.__dict__.iteritems()]
25077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25078 
 
25079 
  def __eq__(self, other):
25080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25081 
 
25082 
  def __ne__(self, other):
25083 
    return not (self == other)
25084 
 
25085 
class getCostingForMarketplace_result:
25086 
  """
25087 
  Attributes:
25088 
   - success
25089 
  """
25090 
 
25091 
  thrift_spec = (
25092 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
25093 
  )
25094 
 
25095 
  def __init__(self, success=None,):
25096 
    self.success = success
25097 
 
25098 
  def read(self, iprot):
25099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25101 
      return
25102 
    iprot.readStructBegin()
25103 
    while True:
25104 
      (fname, ftype, fid) = iprot.readFieldBegin()
25105 
      if ftype == TType.STOP:
25106 
        break
25107 
      if fid == 0:
25108 
        if ftype == TType.STRUCT:
25109 
          self.success = MarketplacePercentage()
25110 
          self.success.read(iprot)
25111 
        else:
25112 
          iprot.skip(ftype)
25113 
      else:
25114 
        iprot.skip(ftype)
25115 
      iprot.readFieldEnd()
25116 
    iprot.readStructEnd()
25117 
 
25118 
  def write(self, oprot):
25119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25121 
      return
25122 
    oprot.writeStructBegin('getCostingForMarketplace_result')
25123 
    if self.success is not None:
25124 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25125 
      self.success.write(oprot)
25126 
      oprot.writeFieldEnd()
25127 
    oprot.writeFieldStop()
25128 
    oprot.writeStructEnd()
25129 
 
25130 
  def validate(self):
25131 
    return
25132 
 
25133 
 
25134 
  def __repr__(self):
25135 
    L = ['%s=%r' % (key, value)
25136 
      for key, value in self.__dict__.iteritems()]
25137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25138 
 
25139 
  def __eq__(self, other):
25140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25141 
 
25142 
  def __ne__(self, other):
25143 
    return not (self == other)
25144 
 
9776 vikram.rag 25145 
class getMarketPlaceItemsForPriceUpdate_args:
25146 
  """
25147 
  Attributes:
25148 
   - source
25149 
  """
25150 
 
25151 
  thrift_spec = (
25152 
    None, # 0
25153 
    (1, TType.I64, 'source', None, None, ), # 1
25154 
  )
25155 
 
25156 
  def __init__(self, source=None,):
25157 
    self.source = source
25158 
 
25159 
  def read(self, iprot):
25160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25162 
      return
25163 
    iprot.readStructBegin()
25164 
    while True:
25165 
      (fname, ftype, fid) = iprot.readFieldBegin()
25166 
      if ftype == TType.STOP:
25167 
        break
25168 
      if fid == 1:
25169 
        if ftype == TType.I64:
25170 
          self.source = iprot.readI64();
25171 
        else:
25172 
          iprot.skip(ftype)
25173 
      else:
25174 
        iprot.skip(ftype)
25175 
      iprot.readFieldEnd()
25176 
    iprot.readStructEnd()
25177 
 
25178 
  def write(self, oprot):
25179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25181 
      return
25182 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
25183 
    if self.source is not None:
25184 
      oprot.writeFieldBegin('source', TType.I64, 1)
25185 
      oprot.writeI64(self.source)
25186 
      oprot.writeFieldEnd()
25187 
    oprot.writeFieldStop()
25188 
    oprot.writeStructEnd()
25189 
 
25190 
  def validate(self):
25191 
    return
25192 
 
25193 
 
25194 
  def __repr__(self):
25195 
    L = ['%s=%r' % (key, value)
25196 
      for key, value in self.__dict__.iteritems()]
25197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25198 
 
25199 
  def __eq__(self, other):
25200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25201 
 
25202 
  def __ne__(self, other):
25203 
    return not (self == other)
25204 
 
25205 
class getMarketPlaceItemsForPriceUpdate_result:
25206 
  """
25207 
  Attributes:
25208 
   - success
25209 
  """
25210 
 
25211 
  thrift_spec = (
25212 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
25213 
  )
25214 
 
25215 
  def __init__(self, success=None,):
25216 
    self.success = success
25217 
 
25218 
  def read(self, iprot):
25219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25221 
      return
25222 
    iprot.readStructBegin()
25223 
    while True:
25224 
      (fname, ftype, fid) = iprot.readFieldBegin()
25225 
      if ftype == TType.STOP:
25226 
        break
25227 
      if fid == 0:
25228 
        if ftype == TType.LIST:
25229 
          self.success = []
25230 
          (_etype558, _size555) = iprot.readListBegin()
25231 
          for _i559 in xrange(_size555):
25232 
            _elem560 = MarketPlaceItemPrice()
25233 
            _elem560.read(iprot)
25234 
            self.success.append(_elem560)
25235 
          iprot.readListEnd()
25236 
        else:
25237 
          iprot.skip(ftype)
25238 
      else:
25239 
        iprot.skip(ftype)
25240 
      iprot.readFieldEnd()
25241 
    iprot.readStructEnd()
25242 
 
25243 
  def write(self, oprot):
25244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25246 
      return
25247 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
25248 
    if self.success is not None:
25249 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25250 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25251 
      for iter561 in self.success:
25252 
        iter561.write(oprot)
25253 
      oprot.writeListEnd()
25254 
      oprot.writeFieldEnd()
25255 
    oprot.writeFieldStop()
25256 
    oprot.writeStructEnd()
25257 
 
25258 
  def validate(self):
25259 
    return
25260 
 
25261 
 
25262 
  def __repr__(self):
25263 
    L = ['%s=%r' % (key, value)
25264 
      for key, value in self.__dict__.iteritems()]
25265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25266 
 
25267 
  def __eq__(self, other):
25268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25269 
 
25270 
  def __ne__(self, other):
25271 
    return not (self == other)
25272 
 
25273 
class updateMarketPlacePriceUpdateStatus_args:
25274 
  """
25275 
  Attributes:
25276 
   - skulist
25277 
   - timestamp
9816 kshitij.so 25278 
   - source
9776 vikram.rag 25279 
  """
25280 
 
25281 
  thrift_spec = (
25282 
    None, # 0
25283 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
25284 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 25285 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 25286 
  )
25287 
 
9816 kshitij.so 25288 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 25289 
    self.skulist = skulist
25290 
    self.timestamp = timestamp
9816 kshitij.so 25291 
    self.source = source
9776 vikram.rag 25292 
 
25293 
  def read(self, iprot):
25294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25296 
      return
25297 
    iprot.readStructBegin()
25298 
    while True:
25299 
      (fname, ftype, fid) = iprot.readFieldBegin()
25300 
      if ftype == TType.STOP:
25301 
        break
25302 
      if fid == 1:
25303 
        if ftype == TType.LIST:
25304 
          self.skulist = []
25305 
          (_etype565, _size562) = iprot.readListBegin()
25306 
          for _i566 in xrange(_size562):
25307 
            _elem567 = iprot.readI64();
25308 
            self.skulist.append(_elem567)
25309 
          iprot.readListEnd()
25310 
        else:
25311 
          iprot.skip(ftype)
25312 
      elif fid == 2:
25313 
        if ftype == TType.I64:
25314 
          self.timestamp = iprot.readI64();
25315 
        else:
25316 
          iprot.skip(ftype)
9816 kshitij.so 25317 
      elif fid == 3:
25318 
        if ftype == TType.I64:
25319 
          self.source = iprot.readI64();
25320 
        else:
25321 
          iprot.skip(ftype)
9776 vikram.rag 25322 
      else:
25323 
        iprot.skip(ftype)
25324 
      iprot.readFieldEnd()
25325 
    iprot.readStructEnd()
25326 
 
25327 
  def write(self, oprot):
25328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25330 
      return
25331 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
25332 
    if self.skulist is not None:
25333 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
25334 
      oprot.writeListBegin(TType.I64, len(self.skulist))
25335 
      for iter568 in self.skulist:
25336 
        oprot.writeI64(iter568)
25337 
      oprot.writeListEnd()
25338 
      oprot.writeFieldEnd()
25339 
    if self.timestamp is not None:
25340 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
25341 
      oprot.writeI64(self.timestamp)
25342 
      oprot.writeFieldEnd()
9816 kshitij.so 25343 
    if self.source is not None:
25344 
      oprot.writeFieldBegin('source', TType.I64, 3)
25345 
      oprot.writeI64(self.source)
25346 
      oprot.writeFieldEnd()
9776 vikram.rag 25347 
    oprot.writeFieldStop()
25348 
    oprot.writeStructEnd()
25349 
 
25350 
  def validate(self):
25351 
    return
25352 
 
25353 
 
25354 
  def __repr__(self):
25355 
    L = ['%s=%r' % (key, value)
25356 
      for key, value in self.__dict__.iteritems()]
25357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25358 
 
25359 
  def __eq__(self, other):
25360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25361 
 
25362 
  def __ne__(self, other):
25363 
    return not (self == other)
25364 
 
25365 
class updateMarketPlacePriceUpdateStatus_result:
25366 
 
25367 
  thrift_spec = (
25368 
  )
25369 
 
25370 
  def read(self, iprot):
25371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25373 
      return
25374 
    iprot.readStructBegin()
25375 
    while True:
25376 
      (fname, ftype, fid) = iprot.readFieldBegin()
25377 
      if ftype == TType.STOP:
25378 
        break
25379 
      else:
25380 
        iprot.skip(ftype)
25381 
      iprot.readFieldEnd()
25382 
    iprot.readStructEnd()
25383 
 
25384 
  def write(self, oprot):
25385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25387 
      return
25388 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
25389 
    oprot.writeFieldStop()
25390 
    oprot.writeStructEnd()
25391 
 
25392 
  def validate(self):
25393 
    return
25394 
 
25395 
 
25396 
  def __repr__(self):
25397 
    L = ['%s=%r' % (key, value)
25398 
      for key, value in self.__dict__.iteritems()]
25399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25400 
 
25401 
  def __eq__(self, other):
25402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25403 
 
25404 
  def __ne__(self, other):
25405 
    return not (self == other)
9861 rajveer 25406 
 
25407 
class updateItemHoldInventory_args:
25408 
  """
25409 
  Attributes:
25410 
   - itemHoldMap
25411 
  """
25412 
 
25413 
  thrift_spec = (
25414 
    None, # 0
25415 
    (1, TType.MAP, 'itemHoldMap', (TType.I64,None,TType.I64,None), None, ), # 1
25416 
  )
25417 
 
25418 
  def __init__(self, itemHoldMap=None,):
25419 
    self.itemHoldMap = itemHoldMap
25420 
 
25421 
  def read(self, iprot):
25422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25424 
      return
25425 
    iprot.readStructBegin()
25426 
    while True:
25427 
      (fname, ftype, fid) = iprot.readFieldBegin()
25428 
      if ftype == TType.STOP:
25429 
        break
25430 
      if fid == 1:
25431 
        if ftype == TType.MAP:
25432 
          self.itemHoldMap = {}
25433 
          (_ktype570, _vtype571, _size569 ) = iprot.readMapBegin()
25434 
          for _i573 in xrange(_size569):
25435 
            _key574 = iprot.readI64();
25436 
            _val575 = iprot.readI64();
25437 
            self.itemHoldMap[_key574] = _val575
25438 
          iprot.readMapEnd()
25439 
        else:
25440 
          iprot.skip(ftype)
25441 
      else:
25442 
        iprot.skip(ftype)
25443 
      iprot.readFieldEnd()
25444 
    iprot.readStructEnd()
25445 
 
25446 
  def write(self, oprot):
25447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25449 
      return
25450 
    oprot.writeStructBegin('updateItemHoldInventory_args')
25451 
    if self.itemHoldMap is not None:
25452 
      oprot.writeFieldBegin('itemHoldMap', TType.MAP, 1)
25453 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemHoldMap))
25454 
      for kiter576,viter577 in self.itemHoldMap.items():
25455 
        oprot.writeI64(kiter576)
25456 
        oprot.writeI64(viter577)
25457 
      oprot.writeMapEnd()
25458 
      oprot.writeFieldEnd()
25459 
    oprot.writeFieldStop()
25460 
    oprot.writeStructEnd()
25461 
 
25462 
  def validate(self):
25463 
    return
25464 
 
25465 
 
25466 
  def __repr__(self):
25467 
    L = ['%s=%r' % (key, value)
25468 
      for key, value in self.__dict__.iteritems()]
25469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25470 
 
25471 
  def __eq__(self, other):
25472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25473 
 
25474 
  def __ne__(self, other):
25475 
    return not (self == other)
25476 
 
25477 
class updateItemHoldInventory_result:
25478 
 
25479 
  thrift_spec = (
25480 
  )
25481 
 
25482 
  def read(self, iprot):
25483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25485 
      return
25486 
    iprot.readStructBegin()
25487 
    while True:
25488 
      (fname, ftype, fid) = iprot.readFieldBegin()
25489 
      if ftype == TType.STOP:
25490 
        break
25491 
      else:
25492 
        iprot.skip(ftype)
25493 
      iprot.readFieldEnd()
25494 
    iprot.readStructEnd()
25495 
 
25496 
  def write(self, oprot):
25497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25499 
      return
25500 
    oprot.writeStructBegin('updateItemHoldInventory_result')
25501 
    oprot.writeFieldStop()
25502 
    oprot.writeStructEnd()
25503 
 
25504 
  def validate(self):
25505 
    return
25506 
 
25507 
 
25508 
  def __repr__(self):
25509 
    L = ['%s=%r' % (key, value)
25510 
      for key, value in self.__dict__.iteritems()]
25511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25512 
 
25513 
  def __eq__(self, other):
25514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25515 
 
25516 
  def __ne__(self, other):
25517 
    return not (self == other)