Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
5944 mandeep.dh 1 
#
2 
# Autogenerated by Thrift Compiler (0.7.0)
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
import shop2020.thriftpy.generic.GenericService
9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol, TProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def addItem(self, item):
21 
    """
22 
    Availability and inventory attributes
23 
 
24 
    Parameters:
25 
     - item
26 
    """
27 
    pass
28 
 
29 
  def updateItem(self, item):
30 
    """
31 
    Parameters:
32 
     - item
33 
    """
34 
    pass
35 
 
36 
  def isActive(self, itemId):
37 
    """
38 
    Checks if the item given to the corresponding itemId is active. If it's active,
39 
    whether it's risky and if it's risky, its inventory position.
40 
 
41 
    Parameters:
42 
     - itemId
43 
    """
44 
    pass
45 
 
7438 amit.gupta 46 
  def getItemsStatus(self, itemIds):
47 
    """
48 
    Parameters:
49 
     - itemIds
50 
    """
51 
    pass
52 
 
5944 mandeep.dh 53 
  def getItemStatusDescription(self, itemId):
54 
    """
55 
    Parameters:
56 
     - itemId
57 
    """
58 
    pass
59 
 
60 
  def startItemOn(self, item_id, timestamp):
61 
    """
62 
    Parameters:
63 
     - item_id
64 
     - timestamp
65 
    """
66 
    pass
67 
 
68 
  def retireItemOn(self, item_id, timestamp):
69 
    """
70 
    Parameters:
71 
     - item_id
72 
     - timestamp
73 
    """
74 
    pass
75 
 
76 
  def changeItemStatus(self, item_id, timestamp, newstatus):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
     - timestamp
81 
     - newstatus
82 
    """
83 
    pass
84 
 
85 
  def getItem(self, item_id):
86 
    """
87 
    Parameters:
88 
     - item_id
89 
    """
90 
    pass
91 
 
92 
  def getItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getValidItemsByCatalogId(self, catalog_item_id):
100 
    """
101 
    Parameters:
102 
     - catalog_item_id
103 
    """
104 
    pass
105 
 
106 
  def getAllItems(self, isActive):
107 
    """
108 
    Parameters:
109 
     - isActive
110 
    """
111 
    pass
112 
 
113 
  def getAllItemsByStatus(self, itemStatus):
114 
    """
115 
    Parameters:
116 
     - itemStatus
117 
    """
118 
    pass
119 
 
9253 rajveer 120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
9253 rajveer 128 
     - isAndroid
5944 mandeep.dh 129 
    """
130 
    pass
131 
 
132 
  def getAllItemsInRange(self, offset, limit):
133 
    """
134 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
135 
 
136 
    Parameters:
137 
     - offset
138 
     - limit
139 
    """
140 
    pass
141 
 
142 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
143 
    """
144 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
145 
 
146 
    Parameters:
147 
     - itemStatus
148 
     - offset
149 
     - limit
150 
    """
151 
    pass
152 
 
153 
  def getItemCountByStatus(self, useStatus, itemStatus):
154 
    """
155 
    Gets a count of all items by status
156 
 
157 
    Parameters:
158 
     - useStatus
159 
     - itemStatus
160 
    """
161 
    pass
162 
 
163 
  def getBestSellers(self, ):
164 
    pass
165 
 
166 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
167 
    """
168 
    Parameters:
169 
     - beginIndex
170 
     - totalItems
171 
     - brand
172 
     - category
173 
    """
174 
    pass
175 
 
176 
  def getBestSellersCount(self, ):
177 
    pass
178 
 
179 
  def getBestDeals(self, ):
180 
    pass
181 
 
182 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
183 
    """
184 
    Parameters:
185 
     - beginIndex
186 
     - totalItems
187 
     - brand
188 
     - category
189 
    """
190 
    pass
191 
 
192 
  def getBestDealsCount(self, ):
193 
    pass
194 
 
195 
  def getComingSoon(self, ):
196 
    pass
197 
 
198 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
199 
    """
200 
    Parameters:
201 
     - beginIndex
202 
     - totalItems
203 
     - brand
204 
     - category
205 
    """
206 
    pass
207 
 
208 
  def getComingSoonCount(self, ):
209 
    pass
210 
 
211 
  def getLatestArrivals(self, ):
212 
    """
213 
    Returns a list of items sorted in the descending order by start date.
214 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
215 
    """
216 
    pass
217 
 
218 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
219 
    """
220 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
221 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
222 
 
223 
    Parameters:
224 
     - beginIndex
225 
     - totalItems
226 
     - brand
227 
     - categories
228 
    """
229 
    pass
230 
 
231 
  def getLatestArrivalsCount(self, ):
232 
    """
233 
    Get the total number of latest arrivals we are willing to show.
234 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
235 
    """
236 
    pass
237 
 
238 
  def generateNewEntityID(self, ):
239 
    pass
240 
 
241 
  def addCategory(self, category):
242 
    """
243 
    All category related functions
244 
 
245 
    Parameters:
246 
     - category
247 
    """
248 
    pass
249 
 
250 
  def getCategory(self, id):
251 
    """
252 
    Parameters:
253 
     - id
254 
    """
255 
    pass
256 
 
257 
  def getAllCategories(self, ):
258 
    pass
259 
 
260 
  def getAllSimilarItems(self, itemId):
261 
    """
262 
    Returns the list of similar items.
263 
 
264 
    Parameters:
265 
     - itemId
266 
    """
267 
    pass
268 
 
269 
  def addSimilarItem(self, itemId, catalogItemId):
270 
    """
271 
    Adds similar item.
272 
 
273 
    Parameters:
274 
     - itemId
275 
     - catalogItemId
276 
    """
277 
    pass
278 
 
6512 kshitij.so 279 
  def addTag(self, displayName, itemId):
280 
    """
281 
    Tag Related
282 
 
283 
    Parameters:
284 
     - displayName
285 
     - itemId
286 
    """
287 
    pass
288 
 
289 
  def deleteEntityTag(self, displayName, itemId):
290 
    """
291 
    Parameters:
292 
     - displayName
293 
     - itemId
294 
    """
295 
    pass
296 
 
297 
  def deleteTag(self, displayName):
298 
    """
299 
    Parameters:
300 
     - displayName
301 
    """
302 
    pass
303 
 
304 
  def getAllTags(self, ):
305 
    pass
306 
 
307 
  def getAllEntitiesByTagName(self, displayName):
308 
    """
309 
    Parameters:
310 
     - displayName
311 
    """
312 
    pass
313 
 
6845 amit.gupta 314 
  def getAllEntityTags(self, ):
315 
    pass
316 
 
8590 kshitij.so 317 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 318 
    """
8579 kshitij.so 319 
    Banner Related
320 
 
6850 kshitij.so 321 
    Parameters:
8590 kshitij.so 322 
     - bannerCongregate
6850 kshitij.so 323 
    """
324 
    pass
325 
 
8579 kshitij.so 326 
  def updateBanner(self, banner):
327 
    """
328 
    Parameters:
329 
     - banner
330 
    """
331 
    pass
332 
 
6850 kshitij.so 333 
  def getAllBanners(self, ):
334 
    pass
335 
 
9155 kshitij.so 336 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 337 
    """
338 
    Parameters:
339 
     - bannerName
9155 kshitij.so 340 
     - bannerType
6850 kshitij.so 341 
    """
342 
    pass
343 
 
9155 kshitij.so 344 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 345 
    """
346 
    Parameters:
347 
     - bannerName
9155 kshitij.so 348 
     - bannerType
6850 kshitij.so 349 
    """
350 
    pass
351 
 
352 
  def getActiveBanners(self, ):
353 
    pass
354 
 
8579 kshitij.so 355 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 356 
    """
357 
    Parameters:
8579 kshitij.so 358 
     - bannerMaps
6849 kshitij.so 359 
    """
360 
    pass
361 
 
8579 kshitij.so 362 
  def updateBannerMap(self, bannerMap):
363 
    """
364 
    Parameters:
365 
     - bannerMap
366 
    """
367 
    pass
368 
 
6849 kshitij.so 369 
  def deleteBannerMap(self, bannerName):
370 
    """
371 
    Parameters:
372 
     - bannerName
373 
    """
374 
    pass
375 
 
9155 kshitij.so 376 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 377 
    """
378 
    Parameters:
379 
     - bannerName
9155 kshitij.so 380 
     - bannerType
6849 kshitij.so 381 
    """
382 
    pass
383 
 
8579 kshitij.so 384 
  def addBannerUri(self, bannerUriMappings):
385 
    """
386 
    Parameters:
387 
     - bannerUriMappings
388 
    """
389 
    pass
390 
 
9155 kshitij.so 391 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 392 
    """
393 
    Parameters:
394 
     - bannerName
9155 kshitij.so 395 
     - bannerType
8579 kshitij.so 396 
    """
397 
    pass
398 
 
399 
  def addCampaign(self, campaign):
400 
    """
401 
    Parameters:
402 
     - campaign
403 
    """
404 
    pass
405 
 
406 
  def getCampaigns(self, campaignName):
407 
    """
408 
    Parameters:
409 
     - campaignName
410 
    """
411 
    pass
412 
 
413 
  def deleteCampaign(self, campaignId):
414 
    """
415 
    Parameters:
416 
     - campaignId
417 
    """
418 
    pass
419 
 
420 
  def getAllCampaigns(self, ):
421 
    pass
422 
 
9155 kshitij.so 423 
  def getActiveBannersForMobileSite(self, ):
424 
    pass
425 
 
5944 mandeep.dh 426 
  def deleteSimilarItem(self, itemId, catalogItemId):
427 
    """
428 
    Delete similar item.
429 
 
430 
    Parameters:
431 
     - itemId
432 
     - catalogItemId
433 
    """
434 
    pass
435 
 
436 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
437 
    """
438 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
439 
    If yes, returns the itemId else returns 0
440 
 
441 
    Parameters:
442 
     - brand
443 
     - modelNumber
444 
     - modelName
445 
     - color
446 
    """
447 
    pass
448 
 
449 
  def validateRiskyStatus(self, itemId):
450 
    """
451 
    Check wether item is risky and change status if inventory is not available for risky items
452 
 
453 
    Parameters:
454 
     - itemId
455 
    """
456 
    pass
457 
 
458 
  def changeItemRiskyFlag(self, itemId, risky):
459 
    """
460 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
461 
 
462 
    Parameters:
463 
     - itemId
464 
     - risky
465 
    """
466 
    pass
467 
 
468 
  def getItemsByRiskyFlag(self, ):
469 
    """
470 
    Returns list of items marked as risky.
471 
    """
472 
    pass
473 
 
474 
  def getItemsForMasterSheet(self, category, brand):
475 
    """
476 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
477 
 
478 
    Parameters:
479 
     - category
480 
     - brand
481 
    """
482 
    pass
483 
 
484 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
485 
    """
486 
    Returns list of catalog ids of items with same similarity index as of the given itemId
487 
 
488 
    Parameters:
489 
     - beginIndex
490 
     - totalItems
491 
     - itemId
492 
    """
493 
    pass
494 
 
495 
  def addProductNotification(self, itemId, email):
496 
    """
497 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
498 
 
499 
    Parameters:
500 
     - itemId
501 
     - email
502 
    """
503 
    pass
504 
 
505 
  def sendProductNotifications(self, ):
506 
    """
507 
    Send the product notifications to the users for items which has stock.
508 
    """
509 
    pass
510 
 
511 
  def getAllBrandsByCategory(self, categoryId):
512 
    """
513 
    Returns list of brand names for a given category Id
514 
 
515 
    Parameters:
516 
     - categoryId
517 
    """
518 
    pass
519 
 
520 
  def getAllBrands(self, ):
521 
    """
522 
    Returns list of brand names
523 
    """
524 
    pass
525 
 
526 
  def getAllSources(self, ):
527 
    """
528 
    Return list of all sources
529 
    """
530 
    pass
531 
 
532 
  def getItemPricingBySource(self, itemId, sourceId):
533 
    """
534 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
535 
 
536 
    Parameters:
537 
     - itemId
538 
     - sourceId
539 
    """
540 
    pass
541 
 
542 
  def addSourceItemPricing(self, sourceItemPricing):
543 
    """
544 
    Adds prices to be displayed corresponding to the item if user comes from a source.
545 
    If item is not found or source is not found, it will throw exception.
546 
 
547 
    Parameters:
548 
     - sourceItemPricing
549 
    """
550 
    pass
551 
 
552 
  def getAllSourcePricing(self, itemId):
553 
    """
554 
    Returns the list of source pricing information of an item.
555 
    Raises an exception if item not found corresponding to itemId
556 
 
557 
    Parameters:
558 
     - itemId
559 
    """
560 
    pass
561 
 
562 
  def getItemForSource(self, item_id, sourceId):
563 
    """
564 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
565 
 
566 
    Parameters:
567 
     - item_id
568 
     - sourceId
569 
    """
570 
    pass
571 
 
572 
  def searchItemsInRange(self, searchTerms, offset, limit):
573 
    """
574 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
575 
 
576 
    Parameters:
577 
     - searchTerms
578 
     - offset
579 
     - limit
580 
    """
581 
    pass
582 
 
583 
  def getSearchResultCount(self, searchTerms):
584 
    """
585 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
586 
 
587 
    Parameters:
588 
     - searchTerms
589 
    """
590 
    pass
591 
 
592 
  def getProductNotifications(self, startDateTime):
593 
    """
594 
    Returns a list of product notifications added after a supplied datetime
595 
 
596 
    Parameters:
597 
     - startDateTime
598 
    """
599 
    pass
600 
 
7897 amar.kumar 601 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 602 
    """
603 
    Returns a list of count of requests for product notification against each item
604 
 
605 
    Parameters:
606 
     - startDateTime
7897 amar.kumar 607 
     - categoryId
5944 mandeep.dh 608 
    """
609 
    pass
610 
 
611 
  def addAuthorizationLog(self, itemId, username, reason):
612 
    """
613 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
614 
 
615 
    Parameters:
616 
     - itemId
617 
     - username
618 
     - reason
619 
    """
620 
    pass
621 
 
622 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
623 
    """
624 
    Parameters:
625 
     - catalog_item_id
626 
     - voucherType
627 
     - voucherAmount
628 
    """
629 
    pass
630 
 
631 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
632 
    """
633 
    Parameters:
634 
     - catalog_item_id
635 
     - voucherType
636 
    """
637 
    pass
638 
 
639 
  def getVoucherAmount(self, itemId, voucherType):
640 
    """
641 
    Parameters:
642 
     - itemId
643 
     - voucherType
644 
    """
645 
    pass
646 
 
647 
  def getAllItemVouchers(self, itemId):
648 
    """
649 
    Parameters:
650 
     - itemId
651 
    """
652 
    pass
653 
 
654 
  def isValidCatalogItemId(self, catalog_item_id):
655 
    """
656 
    Parameters:
657 
     - catalog_item_id
658 
    """
659 
    pass
660 
 
7330 amit.gupta 661 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 662 
    """
663 
    Parameters:
664 
     - itemId
7330 amit.gupta 665 
     - stateId
6039 amit.gupta 666 
     - price
667 
    """
668 
    pass
5944 mandeep.dh 669 
 
6039 amit.gupta 670 
  def getVatAmountForItem(self, itemId, price):
671 
    """
672 
    Parameters:
673 
     - itemId
674 
     - price
675 
    """
676 
    pass
677 
 
6531 vikram.rag 678 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
679 
    """
680 
    Parameters:
681 
     - offset
682 
     - limit
683 
    """
684 
    pass
6039 amit.gupta 685 
 
6821 amar.kumar 686 
  def getAllAliveItems(self, ):
687 
    pass
688 
 
6921 anupam.sin 689 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 690 
    """
691 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 692 
 
6805 anupam.sin 693 
    Parameters:
694 
     - itemId
6921 anupam.sin 695 
     - price
6805 anupam.sin 696 
     - insurerId
697 
     - quantity
698 
    """
699 
    pass
700 
 
701 
  def getInsurer(self, insurerId):
702 
    """
703 
    Parameters:
704 
     - insurerId
705 
    """
706 
    pass
707 
 
6838 vikram.rag 708 
  def getAllInsurers(self, ):
709 
    pass
6805 anupam.sin 710 
 
6962 rajveer 711 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
712 
    """
713 
    Parameters:
714 
     - insurerId
715 
     - amount
716 
    """
717 
    pass
6838 vikram.rag 718 
 
7190 amar.kumar 719 
  def getFreebieForItem(self, itemId):
720 
    """
721 
    Parameters:
722 
     - itemId
723 
    """
724 
    pass
6962 rajveer 725 
 
7190 amar.kumar 726 
  def addOrUpdateFreebieForItem(self, freebieItem):
727 
    """
728 
    Parameters:
729 
     - freebieItem
730 
    """
731 
    pass
732 
 
7272 amit.gupta 733 
  def addOrUpdateBrandInfo(self, brandInfo):
734 
    """
735 
    Parameters:
736 
     - brandInfo
737 
    """
738 
    pass
739 
 
740 
  def getBrandInfo(self, ):
741 
    pass
742 
 
7256 rajveer 743 
  def getStorePricing(self, itemId):
744 
    """
745 
    Parameters:
746 
     - itemId
747 
    """
748 
    pass
7190 amar.kumar 749 
 
7306 rajveer 750 
  def getStorePricings(self, itemIds):
751 
    """
752 
    Parameters:
753 
     - itemIds
754 
    """
755 
    pass
756 
 
7382 rajveer 757 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 758 
    """
759 
    Parameters:
760 
     - sp
7382 rajveer 761 
     - allColors
7265 rajveer 762 
    """
763 
    pass
7256 rajveer 764 
 
7281 kshitij.so 765 
  def getAllAmazonListedItems(self, ):
766 
    pass
7265 rajveer 767 
 
8619 kshitij.so 768 
  def searchAmazonItems(self, searchTerm, offset, limit):
769 
    """
770 
    Parameters:
771 
     - searchTerm
772 
     - offset
773 
     - limit
774 
    """
775 
    pass
776 
 
777 
  def getAmazonSearchResultCount(self, searchTerm):
778 
    """
779 
    Parameters:
780 
     - searchTerm
781 
    """
782 
    pass
783 
 
784 
  def getCountForAmazonlistedItems(self, ):
785 
    pass
786 
 
7281 kshitij.so 787 
  def getAmazonItemDetails(self, itemId):
788 
    """
789 
    Parameters:
790 
     - itemId
791 
    """
792 
    pass
793 
 
8168 kshitij.so 794 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 795 
    """
796 
    Parameters:
8168 kshitij.so 797 
     - amazonlisted
7281 kshitij.so 798 
    """
799 
    pass
800 
 
801 
  def addAmazonItem(self, amazonlisted):
802 
    """
803 
    Parameters:
804 
     - amazonlisted
805 
    """
806 
    pass
807 
 
7291 vikram.rag 808 
  def getAsinItems(self, ):
809 
    pass
7281 kshitij.so 810 
 
7291 vikram.rag 811 
  def getAllFbaListedItems(self, ):
812 
    pass
813 
 
814 
  def getAllNonFbaListedItems(self, ):
815 
    pass
816 
 
7460 kshitij.so 817 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
818 
    """
819 
    Parameters:
820 
     - itemId
821 
     - holdInventory
822 
     - defaultInventory
823 
    """
824 
    pass
7291 vikram.rag 825 
 
7770 kshitij.so 826 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
827 
    """
828 
    Parameters:
829 
     - type
830 
     - sku
831 
     - timestamp
832 
    """
833 
    pass
7460 kshitij.so 834 
 
7897 amar.kumar 835 
  def getAllParentCategories(self, ):
836 
    pass
7770 kshitij.so 837 
 
7977 kshitij.so 838 
  def addPageViewEvent(self, pageViewEvents):
839 
    """
840 
    Parameters:
841 
     - pageViewEvents
842 
    """
843 
    pass
7897 amar.kumar 844 
 
7977 kshitij.so 845 
  def addCartEvent(self, cartEvents):
846 
    """
847 
    Parameters:
848 
     - cartEvents
849 
    """
850 
    pass
851 
 
8182 amar.kumar 852 
  def addEbayItem(self, ebayItem):
853 
    """
854 
    Parameters:
855 
     - ebayItem
856 
    """
857 
    pass
858 
 
859 
  def getEbayItem(self, listingId):
860 
    """
861 
    Parameters:
862 
     - listingId
863 
    """
864 
    pass
865 
 
866 
  def updateEbayItem(self, ebayItem):
867 
    """
868 
    Parameters:
869 
     - ebayItem
870 
    """
871 
    pass
872 
 
8139 kshitij.so 873 
  def getAmazonListedItems(self, offset, limit):
874 
    """
875 
    Parameters:
876 
     - offset
877 
     - limit
878 
    """
879 
    pass
7977 kshitij.so 880 
 
8168 kshitij.so 881 
  def updateAmazonAttributesInBulk(self, amazonlisted):
882 
    """
883 
    Parameters:
884 
     - amazonlisted
885 
    """
886 
    pass
8139 kshitij.so 887 
 
8379 vikram.rag 888 
  def getAllItemstoListOnFba(self, ):
889 
    pass
8168 kshitij.so 890 
 
8379 vikram.rag 891 
  def getAllItemstoListOnNonFba(self, ):
892 
    pass
893 
 
8619 kshitij.so 894 
  def updateAsin(self, item):
895 
    """
896 
    Parameters:
897 
     - item
898 
    """
899 
    pass
8616 vikram.rag 900 
 
8739 vikram.rag 901 
  def addOrUpdateSnapdealItem(self, snapdealitem):
902 
    """
903 
    Parameters:
904 
     - snapdealitem
905 
    """
906 
    pass
8619 kshitij.so 907 
 
8739 vikram.rag 908 
  def getSnapdealItem(self, item_id):
909 
    """
910 
    Parameters:
911 
     - item_id
912 
    """
913 
    pass
914 
 
9242 kshitij.so 915 
  def getSnapdealItemDetails(self, item_id):
916 
    """
917 
    Parameters:
918 
     - item_id
919 
    """
920 
    pass
921 
 
8739 vikram.rag 922 
  def getAllSnapdealItems(self, ):
923 
    pass
924 
 
9242 kshitij.so 925 
  def getSnapdealItems(self, offset, limit):
926 
    """
927 
    Parameters:
928 
     - offset
929 
     - limit
930 
    """
931 
    pass
8739 vikram.rag 932 
 
9242 kshitij.so 933 
  def searchSnapdealItems(self, searchTerm, offset, limit):
934 
    """
935 
    Parameters:
936 
     - searchTerm
937 
     - offset
938 
     - limit
939 
    """
940 
    pass
941 
 
942 
  def getCountForSnapdealItems(self, ):
943 
    pass
944 
 
945 
  def getSnapdealSearchResultCount(self, searchTerm):
946 
    """
947 
    Parameters:
948 
     - searchTerm
949 
    """
950 
    pass
951 
 
9299 kshitij.so 952 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
953 
    """
954 
    Parameters:
955 
     - itemId
956 
     - insurerType
957 
    """
958 
    pass
9242 kshitij.so 959 
 
9456 vikram.rag 960 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
961 
    """
962 
    Parameters:
963 
     - skuAtSnapdeal
964 
    """
965 
    pass
9299 kshitij.so 966 
 
9621 manish.sha 967 
  def getProductFeedSubmit(self, catalogItemId):
968 
    """
969 
    Parameters:
970 
     - catalogItemId
971 
    """
972 
    pass
9456 vikram.rag 973 
 
9621 manish.sha 974 
  def addProductFeedSubmit(self, productFeedSubmit):
975 
    """
976 
    Parameters:
977 
     - productFeedSubmit
978 
    """
979 
    pass
980 
 
981 
  def updateProductFeedSubmit(self, productFeedSubmit):
982 
    """
983 
    Parameters:
984 
     - productFeedSubmit
985 
    """
986 
    pass
987 
 
988 
  def deleteProductFeedSubmit(self, catalogItemId):
989 
    """
990 
    Parameters:
991 
     - catalogItemId
992 
    """
993 
    pass
994 
 
995 
  def getAllProductFeedSubmit(self, ):
996 
    pass
997 
 
9724 kshitij.so 998 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
999 
    """
1000 
    Parameters:
1001 
     - itemId
1002 
     - sourceId
1003 
    """
1004 
    pass
9621 manish.sha 1005 
 
9724 kshitij.so 1006 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
1007 
    """
1008 
    Parameters:
1009 
     - marketPlaceItem
1010 
    """
1011 
    pass
1012 
 
9779 kshitij.so 1013 
  def getCostingForMarketplace(self, source, item_id):
1014 
    """
1015 
    Parameters:
1016 
     - source
1017 
     - item_id
1018 
    """
1019 
    pass
1020 
 
9776 vikram.rag 1021 
  def getMarketPlaceItemsForPriceUpdate(self, source):
1022 
    """
1023 
    Parameters:
1024 
     - source
1025 
    """
1026 
    pass
9724 kshitij.so 1027 
 
9816 kshitij.so 1028 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 1029 
    """
1030 
    Parameters:
1031 
     - skulist
1032 
     - timestamp
9816 kshitij.so 1033 
     - source
9776 vikram.rag 1034 
    """
1035 
    pass
1036 
 
9861 rajveer 1037 
  def updateItemHoldInventory(self, itemHoldMap):
1038 
    """
1039 
    Parameters:
1040 
     - itemHoldMap
1041 
    """
1042 
    pass
9776 vikram.rag 1043 
 
9895 vikram.rag 1044 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
1045 
    """
1046 
    Parameters:
1047 
     - item_id
1048 
     - vendor_id
1049 
     - nlc
1050 
    """
1051 
    pass
9861 rajveer 1052 
 
9945 vikram.rag 1053 
  def getAllFlipkartItems(self, ):
1054 
    pass
9895 vikram.rag 1055 
 
10097 kshitij.so 1056 
  def addOrUpdateFlipkartItem(self, flipkartitem):
1057 
    """
1058 
    Parameters:
1059 
     - flipkartitem
1060 
    """
1061 
    pass
9945 vikram.rag 1062 
 
10097 kshitij.so 1063 
  def getFlipkartItem(self, item_id):
1064 
    """
1065 
    Parameters:
1066 
     - item_id
1067 
    """
1068 
    pass
1069 
 
1070 
  def getFlipkartItemDetails(self, item_id):
1071 
    """
1072 
    Parameters:
1073 
     - item_id
1074 
    """
1075 
    pass
1076 
 
1077 
  def getFlipkartItems(self, offset, limit):
1078 
    """
1079 
    Parameters:
1080 
     - offset
1081 
     - limit
1082 
    """
1083 
    pass
1084 
 
1085 
  def searchFlipkartItems(self, searchTerm, offset, limit):
1086 
    """
1087 
    Parameters:
1088 
     - searchTerm
1089 
     - offset
1090 
     - limit
1091 
    """
1092 
    pass
1093 
 
1094 
  def getCountForFlipkartItems(self, ):
1095 
    pass
1096 
 
1097 
  def getFlipkartSearchResultCount(self, searchTerm):
1098 
    """
1099 
    Parameters:
1100 
     - searchTerm
1101 
    """
1102 
    pass
1103 
 
1104 
  def getAllFkItems(self, ):
1105 
    pass
1106 
 
10140 vikram.rag 1107 
  def getFlipkartItemBySkyAtFlipkart(self, sku):
1108 
    """
1109 
    Parameters:
1110 
     - sku
1111 
    """
1112 
    pass
10097 kshitij.so 1113 
 
11015 kshitij.so 1114 
  def getMarketplaceHistory(self, source, offset, itemId):
1115 
    """
1116 
    Parameters:
1117 
     - source
1118 
     - offset
1119 
     - itemId
1120 
    """
1121 
    pass
1122 
 
10909 vikram.rag 1123 
  def getAllFbbListedItems(self, ):
1124 
    pass
10140 vikram.rag 1125 
 
10924 vikram.rag 1126 
  def getAllFbbPricingItems(self, ):
1127 
    pass
10909 vikram.rag 1128 
 
11015 kshitij.so 1129 
  def getCountForMarketplaceHistory(self, source, itemId):
1130 
    """
1131 
    Parameters:
1132 
     - source
1133 
     - itemId
1134 
    """
1135 
    pass
10924 vikram.rag 1136 
 
11015 kshitij.so 1137 
  def getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
1138 
    """
1139 
    Parameters:
1140 
     - source
1141 
     - startDate
1142 
     - endDate
1143 
     - offset
1144 
     - limit
1145 
     - itemId
1146 
    """
1147 
    pass
1148 
 
11531 vikram.rag 1149 
  def getPrivateDealDetails(self, item_id):
1150 
    """
1151 
    Parameters:
1152 
     - item_id
1153 
    """
1154 
    pass
11015 kshitij.so 1155 
 
11531 vikram.rag 1156 
  def getPrivateDealItems(self, offset, limit):
1157 
    """
1158 
    Parameters:
1159 
     - offset
1160 
     - limit
1161 
    """
1162 
    pass
1163 
 
11653 amit.gupta 1164 
  def getAllActivePrivateDeals(self, itemIds, daysDelta):
1165 
    """
1166 
    Parameters:
1167 
     - itemIds
1168 
     - daysDelta
1169 
    """
11592 amit.gupta 1170 
    pass
1171 
 
11531 vikram.rag 1172 
  def addOrUpdatePrivateDeal(self, privateDeal):
1173 
    """
1174 
    Parameters:
1175 
     - privateDeal
1176 
    """
1177 
    pass
1178 
 
11635 vikram.rag 1179 
  def getPrivateDealsCatalogIds(self, beginIndex, totalItems):
1180 
    """
1181 
    Parameters:
1182 
     - beginIndex
1183 
     - totalItems
1184 
    """
1185 
    pass
11531 vikram.rag 1186 
 
11645 amit.gupta 1187 
  def getPrivateDealsCount(self, ):
1188 
    pass
11635 vikram.rag 1189 
 
11645 amit.gupta 1190 
 
5944 mandeep.dh 1191 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1192 
  def __init__(self, iprot, oprot=None):
1193 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1194 
 
1195 
  def addItem(self, item):
1196 
    """
1197 
    Availability and inventory attributes
1198 
 
1199 
    Parameters:
1200 
     - item
1201 
    """
1202 
    self.send_addItem(item)
1203 
    return self.recv_addItem()
1204 
 
1205 
  def send_addItem(self, item):
1206 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1207 
    args = addItem_args()
1208 
    args.item = item
1209 
    args.write(self._oprot)
1210 
    self._oprot.writeMessageEnd()
1211 
    self._oprot.trans.flush()
1212 
 
1213 
  def recv_addItem(self, ):
1214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1215 
    if mtype == TMessageType.EXCEPTION:
1216 
      x = TApplicationException()
1217 
      x.read(self._iprot)
1218 
      self._iprot.readMessageEnd()
1219 
      raise x
1220 
    result = addItem_result()
1221 
    result.read(self._iprot)
1222 
    self._iprot.readMessageEnd()
1223 
    if result.success is not None:
1224 
      return result.success
1225 
    if result.cex is not None:
1226 
      raise result.cex
1227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1228 
 
1229 
  def updateItem(self, item):
1230 
    """
1231 
    Parameters:
1232 
     - item
1233 
    """
1234 
    self.send_updateItem(item)
1235 
    return self.recv_updateItem()
1236 
 
1237 
  def send_updateItem(self, item):
1238 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1239 
    args = updateItem_args()
1240 
    args.item = item
1241 
    args.write(self._oprot)
1242 
    self._oprot.writeMessageEnd()
1243 
    self._oprot.trans.flush()
1244 
 
1245 
  def recv_updateItem(self, ):
1246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1247 
    if mtype == TMessageType.EXCEPTION:
1248 
      x = TApplicationException()
1249 
      x.read(self._iprot)
1250 
      self._iprot.readMessageEnd()
1251 
      raise x
1252 
    result = updateItem_result()
1253 
    result.read(self._iprot)
1254 
    self._iprot.readMessageEnd()
1255 
    if result.success is not None:
1256 
      return result.success
1257 
    if result.cex is not None:
1258 
      raise result.cex
1259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1260 
 
1261 
  def isActive(self, itemId):
1262 
    """
1263 
    Checks if the item given to the corresponding itemId is active. If it's active,
1264 
    whether it's risky and if it's risky, its inventory position.
1265 
 
1266 
    Parameters:
1267 
     - itemId
1268 
    """
1269 
    self.send_isActive(itemId)
1270 
    return self.recv_isActive()
1271 
 
1272 
  def send_isActive(self, itemId):
1273 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1274 
    args = isActive_args()
1275 
    args.itemId = itemId
1276 
    args.write(self._oprot)
1277 
    self._oprot.writeMessageEnd()
1278 
    self._oprot.trans.flush()
1279 
 
1280 
  def recv_isActive(self, ):
1281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1282 
    if mtype == TMessageType.EXCEPTION:
1283 
      x = TApplicationException()
1284 
      x.read(self._iprot)
1285 
      self._iprot.readMessageEnd()
1286 
      raise x
1287 
    result = isActive_result()
1288 
    result.read(self._iprot)
1289 
    self._iprot.readMessageEnd()
1290 
    if result.success is not None:
1291 
      return result.success
1292 
    if result.isex is not None:
1293 
      raise result.isex
1294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1295 
 
7438 amit.gupta 1296 
  def getItemsStatus(self, itemIds):
1297 
    """
1298 
    Parameters:
1299 
     - itemIds
1300 
    """
1301 
    self.send_getItemsStatus(itemIds)
1302 
    return self.recv_getItemsStatus()
1303 
 
1304 
  def send_getItemsStatus(self, itemIds):
1305 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1306 
    args = getItemsStatus_args()
1307 
    args.itemIds = itemIds
1308 
    args.write(self._oprot)
1309 
    self._oprot.writeMessageEnd()
1310 
    self._oprot.trans.flush()
1311 
 
1312 
  def recv_getItemsStatus(self, ):
1313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1314 
    if mtype == TMessageType.EXCEPTION:
1315 
      x = TApplicationException()
1316 
      x.read(self._iprot)
1317 
      self._iprot.readMessageEnd()
1318 
      raise x
1319 
    result = getItemsStatus_result()
1320 
    result.read(self._iprot)
1321 
    self._iprot.readMessageEnd()
1322 
    if result.success is not None:
1323 
      return result.success
1324 
    if result.isex is not None:
1325 
      raise result.isex
1326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1327 
 
5944 mandeep.dh 1328 
  def getItemStatusDescription(self, itemId):
1329 
    """
1330 
    Parameters:
1331 
     - itemId
1332 
    """
1333 
    self.send_getItemStatusDescription(itemId)
1334 
    return self.recv_getItemStatusDescription()
1335 
 
1336 
  def send_getItemStatusDescription(self, itemId):
1337 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1338 
    args = getItemStatusDescription_args()
1339 
    args.itemId = itemId
1340 
    args.write(self._oprot)
1341 
    self._oprot.writeMessageEnd()
1342 
    self._oprot.trans.flush()
1343 
 
1344 
  def recv_getItemStatusDescription(self, ):
1345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1346 
    if mtype == TMessageType.EXCEPTION:
1347 
      x = TApplicationException()
1348 
      x.read(self._iprot)
1349 
      self._iprot.readMessageEnd()
1350 
      raise x
1351 
    result = getItemStatusDescription_result()
1352 
    result.read(self._iprot)
1353 
    self._iprot.readMessageEnd()
1354 
    if result.success is not None:
1355 
      return result.success
1356 
    if result.isex is not None:
1357 
      raise result.isex
1358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1359 
 
1360 
  def startItemOn(self, item_id, timestamp):
1361 
    """
1362 
    Parameters:
1363 
     - item_id
1364 
     - timestamp
1365 
    """
1366 
    self.send_startItemOn(item_id, timestamp)
1367 
    self.recv_startItemOn()
1368 
 
1369 
  def send_startItemOn(self, item_id, timestamp):
1370 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1371 
    args = startItemOn_args()
1372 
    args.item_id = item_id
1373 
    args.timestamp = timestamp
1374 
    args.write(self._oprot)
1375 
    self._oprot.writeMessageEnd()
1376 
    self._oprot.trans.flush()
1377 
 
1378 
  def recv_startItemOn(self, ):
1379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1380 
    if mtype == TMessageType.EXCEPTION:
1381 
      x = TApplicationException()
1382 
      x.read(self._iprot)
1383 
      self._iprot.readMessageEnd()
1384 
      raise x
1385 
    result = startItemOn_result()
1386 
    result.read(self._iprot)
1387 
    self._iprot.readMessageEnd()
1388 
    if result.cex is not None:
1389 
      raise result.cex
1390 
    return
1391 
 
1392 
  def retireItemOn(self, item_id, timestamp):
1393 
    """
1394 
    Parameters:
1395 
     - item_id
1396 
     - timestamp
1397 
    """
1398 
    self.send_retireItemOn(item_id, timestamp)
1399 
    self.recv_retireItemOn()
1400 
 
1401 
  def send_retireItemOn(self, item_id, timestamp):
1402 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1403 
    args = retireItemOn_args()
1404 
    args.item_id = item_id
1405 
    args.timestamp = timestamp
1406 
    args.write(self._oprot)
1407 
    self._oprot.writeMessageEnd()
1408 
    self._oprot.trans.flush()
1409 
 
1410 
  def recv_retireItemOn(self, ):
1411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1412 
    if mtype == TMessageType.EXCEPTION:
1413 
      x = TApplicationException()
1414 
      x.read(self._iprot)
1415 
      self._iprot.readMessageEnd()
1416 
      raise x
1417 
    result = retireItemOn_result()
1418 
    result.read(self._iprot)
1419 
    self._iprot.readMessageEnd()
1420 
    if result.cex is not None:
1421 
      raise result.cex
1422 
    return
1423 
 
1424 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1425 
    """
1426 
    Parameters:
1427 
     - item_id
1428 
     - timestamp
1429 
     - newstatus
1430 
    """
1431 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1432 
    self.recv_changeItemStatus()
1433 
 
1434 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1435 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1436 
    args = changeItemStatus_args()
1437 
    args.item_id = item_id
1438 
    args.timestamp = timestamp
1439 
    args.newstatus = newstatus
1440 
    args.write(self._oprot)
1441 
    self._oprot.writeMessageEnd()
1442 
    self._oprot.trans.flush()
1443 
 
1444 
  def recv_changeItemStatus(self, ):
1445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1446 
    if mtype == TMessageType.EXCEPTION:
1447 
      x = TApplicationException()
1448 
      x.read(self._iprot)
1449 
      self._iprot.readMessageEnd()
1450 
      raise x
1451 
    result = changeItemStatus_result()
1452 
    result.read(self._iprot)
1453 
    self._iprot.readMessageEnd()
1454 
    if result.cex is not None:
1455 
      raise result.cex
1456 
    return
1457 
 
1458 
  def getItem(self, item_id):
1459 
    """
1460 
    Parameters:
1461 
     - item_id
1462 
    """
1463 
    self.send_getItem(item_id)
1464 
    return self.recv_getItem()
1465 
 
1466 
  def send_getItem(self, item_id):
1467 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1468 
    args = getItem_args()
1469 
    args.item_id = item_id
1470 
    args.write(self._oprot)
1471 
    self._oprot.writeMessageEnd()
1472 
    self._oprot.trans.flush()
1473 
 
1474 
  def recv_getItem(self, ):
1475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1476 
    if mtype == TMessageType.EXCEPTION:
1477 
      x = TApplicationException()
1478 
      x.read(self._iprot)
1479 
      self._iprot.readMessageEnd()
1480 
      raise x
1481 
    result = getItem_result()
1482 
    result.read(self._iprot)
1483 
    self._iprot.readMessageEnd()
1484 
    if result.success is not None:
1485 
      return result.success
1486 
    if result.cex is not None:
1487 
      raise result.cex
1488 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1489 
 
1490 
  def getItemsByCatalogId(self, catalog_item_id):
1491 
    """
1492 
    Parameters:
1493 
     - catalog_item_id
1494 
    """
1495 
    self.send_getItemsByCatalogId(catalog_item_id)
1496 
    return self.recv_getItemsByCatalogId()
1497 
 
1498 
  def send_getItemsByCatalogId(self, catalog_item_id):
1499 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1500 
    args = getItemsByCatalogId_args()
1501 
    args.catalog_item_id = catalog_item_id
1502 
    args.write(self._oprot)
1503 
    self._oprot.writeMessageEnd()
1504 
    self._oprot.trans.flush()
1505 
 
1506 
  def recv_getItemsByCatalogId(self, ):
1507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1508 
    if mtype == TMessageType.EXCEPTION:
1509 
      x = TApplicationException()
1510 
      x.read(self._iprot)
1511 
      self._iprot.readMessageEnd()
1512 
      raise x
1513 
    result = getItemsByCatalogId_result()
1514 
    result.read(self._iprot)
1515 
    self._iprot.readMessageEnd()
1516 
    if result.success is not None:
1517 
      return result.success
1518 
    if result.cex is not None:
1519 
      raise result.cex
1520 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1521 
 
1522 
  def getValidItemsByCatalogId(self, catalog_item_id):
1523 
    """
1524 
    Parameters:
1525 
     - catalog_item_id
1526 
    """
1527 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1528 
    return self.recv_getValidItemsByCatalogId()
1529 
 
1530 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1531 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1532 
    args = getValidItemsByCatalogId_args()
1533 
    args.catalog_item_id = catalog_item_id
1534 
    args.write(self._oprot)
1535 
    self._oprot.writeMessageEnd()
1536 
    self._oprot.trans.flush()
1537 
 
1538 
  def recv_getValidItemsByCatalogId(self, ):
1539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1540 
    if mtype == TMessageType.EXCEPTION:
1541 
      x = TApplicationException()
1542 
      x.read(self._iprot)
1543 
      self._iprot.readMessageEnd()
1544 
      raise x
1545 
    result = getValidItemsByCatalogId_result()
1546 
    result.read(self._iprot)
1547 
    self._iprot.readMessageEnd()
1548 
    if result.success is not None:
1549 
      return result.success
1550 
    if result.cex is not None:
1551 
      raise result.cex
1552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1553 
 
1554 
  def getAllItems(self, isActive):
1555 
    """
1556 
    Parameters:
1557 
     - isActive
1558 
    """
1559 
    self.send_getAllItems(isActive)
1560 
    return self.recv_getAllItems()
1561 
 
1562 
  def send_getAllItems(self, isActive):
1563 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1564 
    args = getAllItems_args()
1565 
    args.isActive = isActive
1566 
    args.write(self._oprot)
1567 
    self._oprot.writeMessageEnd()
1568 
    self._oprot.trans.flush()
1569 
 
1570 
  def recv_getAllItems(self, ):
1571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1572 
    if mtype == TMessageType.EXCEPTION:
1573 
      x = TApplicationException()
1574 
      x.read(self._iprot)
1575 
      self._iprot.readMessageEnd()
1576 
      raise x
1577 
    result = getAllItems_result()
1578 
    result.read(self._iprot)
1579 
    self._iprot.readMessageEnd()
1580 
    if result.success is not None:
1581 
      return result.success
1582 
    if result.cex is not None:
1583 
      raise result.cex
1584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1585 
 
1586 
  def getAllItemsByStatus(self, itemStatus):
1587 
    """
1588 
    Parameters:
1589 
     - itemStatus
1590 
    """
1591 
    self.send_getAllItemsByStatus(itemStatus)
1592 
    return self.recv_getAllItemsByStatus()
1593 
 
1594 
  def send_getAllItemsByStatus(self, itemStatus):
1595 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1596 
    args = getAllItemsByStatus_args()
1597 
    args.itemStatus = itemStatus
1598 
    args.write(self._oprot)
1599 
    self._oprot.writeMessageEnd()
1600 
    self._oprot.trans.flush()
1601 
 
1602 
  def recv_getAllItemsByStatus(self, ):
1603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1604 
    if mtype == TMessageType.EXCEPTION:
1605 
      x = TApplicationException()
1606 
      x.read(self._iprot)
1607 
      self._iprot.readMessageEnd()
1608 
      raise x
1609 
    result = getAllItemsByStatus_result()
1610 
    result.read(self._iprot)
1611 
    self._iprot.readMessageEnd()
1612 
    if result.success is not None:
1613 
      return result.success
1614 
    if result.cex is not None:
1615 
      raise result.cex
1616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1617 
 
9253 rajveer 1618 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1619 
    """
1620 
    Parameters:
1621 
     - entityId
1622 
     - category
1623 
     - brand
1624 
     - modelName
1625 
     - modelNumber
9253 rajveer 1626 
     - isAndroid
5944 mandeep.dh 1627 
    """
9253 rajveer 1628 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1629 
    return self.recv_markItemAsContentComplete()
1630 
 
9253 rajveer 1631 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1632 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1633 
    args = markItemAsContentComplete_args()
1634 
    args.entityId = entityId
1635 
    args.category = category
1636 
    args.brand = brand
1637 
    args.modelName = modelName
1638 
    args.modelNumber = modelNumber
9253 rajveer 1639 
    args.isAndroid = isAndroid
5944 mandeep.dh 1640 
    args.write(self._oprot)
1641 
    self._oprot.writeMessageEnd()
1642 
    self._oprot.trans.flush()
1643 
 
1644 
  def recv_markItemAsContentComplete(self, ):
1645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1646 
    if mtype == TMessageType.EXCEPTION:
1647 
      x = TApplicationException()
1648 
      x.read(self._iprot)
1649 
      self._iprot.readMessageEnd()
1650 
      raise x
1651 
    result = markItemAsContentComplete_result()
1652 
    result.read(self._iprot)
1653 
    self._iprot.readMessageEnd()
1654 
    if result.success is not None:
1655 
      return result.success
1656 
    if result.cex is not None:
1657 
      raise result.cex
1658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1659 
 
1660 
  def getAllItemsInRange(self, offset, limit):
1661 
    """
1662 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1663 
 
1664 
    Parameters:
1665 
     - offset
1666 
     - limit
1667 
    """
1668 
    self.send_getAllItemsInRange(offset, limit)
1669 
    return self.recv_getAllItemsInRange()
1670 
 
1671 
  def send_getAllItemsInRange(self, offset, limit):
1672 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1673 
    args = getAllItemsInRange_args()
1674 
    args.offset = offset
1675 
    args.limit = limit
1676 
    args.write(self._oprot)
1677 
    self._oprot.writeMessageEnd()
1678 
    self._oprot.trans.flush()
1679 
 
1680 
  def recv_getAllItemsInRange(self, ):
1681 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1682 
    if mtype == TMessageType.EXCEPTION:
1683 
      x = TApplicationException()
1684 
      x.read(self._iprot)
1685 
      self._iprot.readMessageEnd()
1686 
      raise x
1687 
    result = getAllItemsInRange_result()
1688 
    result.read(self._iprot)
1689 
    self._iprot.readMessageEnd()
1690 
    if result.success is not None:
1691 
      return result.success
1692 
    if result.cex is not None:
1693 
      raise result.cex
1694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1695 
 
1696 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1697 
    """
1698 
    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.
1699 
 
1700 
    Parameters:
1701 
     - itemStatus
1702 
     - offset
1703 
     - limit
1704 
    """
1705 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1706 
    return self.recv_getAllItemsByStatusInRange()
1707 
 
1708 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1709 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1710 
    args = getAllItemsByStatusInRange_args()
1711 
    args.itemStatus = itemStatus
1712 
    args.offset = offset
1713 
    args.limit = limit
1714 
    args.write(self._oprot)
1715 
    self._oprot.writeMessageEnd()
1716 
    self._oprot.trans.flush()
1717 
 
1718 
  def recv_getAllItemsByStatusInRange(self, ):
1719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1720 
    if mtype == TMessageType.EXCEPTION:
1721 
      x = TApplicationException()
1722 
      x.read(self._iprot)
1723 
      self._iprot.readMessageEnd()
1724 
      raise x
1725 
    result = getAllItemsByStatusInRange_result()
1726 
    result.read(self._iprot)
1727 
    self._iprot.readMessageEnd()
1728 
    if result.success is not None:
1729 
      return result.success
1730 
    if result.cex is not None:
1731 
      raise result.cex
1732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1733 
 
1734 
  def getItemCountByStatus(self, useStatus, itemStatus):
1735 
    """
1736 
    Gets a count of all items by status
1737 
 
1738 
    Parameters:
1739 
     - useStatus
1740 
     - itemStatus
1741 
    """
1742 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1743 
    return self.recv_getItemCountByStatus()
1744 
 
1745 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1746 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1747 
    args = getItemCountByStatus_args()
1748 
    args.useStatus = useStatus
1749 
    args.itemStatus = itemStatus
1750 
    args.write(self._oprot)
1751 
    self._oprot.writeMessageEnd()
1752 
    self._oprot.trans.flush()
1753 
 
1754 
  def recv_getItemCountByStatus(self, ):
1755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1756 
    if mtype == TMessageType.EXCEPTION:
1757 
      x = TApplicationException()
1758 
      x.read(self._iprot)
1759 
      self._iprot.readMessageEnd()
1760 
      raise x
1761 
    result = getItemCountByStatus_result()
1762 
    result.read(self._iprot)
1763 
    self._iprot.readMessageEnd()
1764 
    if result.success is not None:
1765 
      return result.success
1766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1767 
 
1768 
  def getBestSellers(self, ):
1769 
    self.send_getBestSellers()
1770 
    return self.recv_getBestSellers()
1771 
 
1772 
  def send_getBestSellers(self, ):
1773 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1774 
    args = getBestSellers_args()
1775 
    args.write(self._oprot)
1776 
    self._oprot.writeMessageEnd()
1777 
    self._oprot.trans.flush()
1778 
 
1779 
  def recv_getBestSellers(self, ):
1780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1781 
    if mtype == TMessageType.EXCEPTION:
1782 
      x = TApplicationException()
1783 
      x.read(self._iprot)
1784 
      self._iprot.readMessageEnd()
1785 
      raise x
1786 
    result = getBestSellers_result()
1787 
    result.read(self._iprot)
1788 
    self._iprot.readMessageEnd()
1789 
    if result.success is not None:
1790 
      return result.success
1791 
    if result.isex is not None:
1792 
      raise result.isex
1793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1794 
 
1795 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1796 
    """
1797 
    Parameters:
1798 
     - beginIndex
1799 
     - totalItems
1800 
     - brand
1801 
     - category
1802 
    """
1803 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1804 
    return self.recv_getBestSellersCatalogIds()
1805 
 
1806 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1807 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1808 
    args = getBestSellersCatalogIds_args()
1809 
    args.beginIndex = beginIndex
1810 
    args.totalItems = totalItems
1811 
    args.brand = brand
1812 
    args.category = category
1813 
    args.write(self._oprot)
1814 
    self._oprot.writeMessageEnd()
1815 
    self._oprot.trans.flush()
1816 
 
1817 
  def recv_getBestSellersCatalogIds(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 = getBestSellersCatalogIds_result()
1825 
    result.read(self._iprot)
1826 
    self._iprot.readMessageEnd()
1827 
    if result.success is not None:
1828 
      return result.success
1829 
    if result.cex is not None:
1830 
      raise result.cex
1831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1832 
 
1833 
  def getBestSellersCount(self, ):
1834 
    self.send_getBestSellersCount()
1835 
    return self.recv_getBestSellersCount()
1836 
 
1837 
  def send_getBestSellersCount(self, ):
1838 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1839 
    args = getBestSellersCount_args()
1840 
    args.write(self._oprot)
1841 
    self._oprot.writeMessageEnd()
1842 
    self._oprot.trans.flush()
1843 
 
1844 
  def recv_getBestSellersCount(self, ):
1845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1846 
    if mtype == TMessageType.EXCEPTION:
1847 
      x = TApplicationException()
1848 
      x.read(self._iprot)
1849 
      self._iprot.readMessageEnd()
1850 
      raise x
1851 
    result = getBestSellersCount_result()
1852 
    result.read(self._iprot)
1853 
    self._iprot.readMessageEnd()
1854 
    if result.success is not None:
1855 
      return result.success
1856 
    if result.cex is not None:
1857 
      raise result.cex
1858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1859 
 
1860 
  def getBestDeals(self, ):
1861 
    self.send_getBestDeals()
1862 
    return self.recv_getBestDeals()
1863 
 
1864 
  def send_getBestDeals(self, ):
1865 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1866 
    args = getBestDeals_args()
1867 
    args.write(self._oprot)
1868 
    self._oprot.writeMessageEnd()
1869 
    self._oprot.trans.flush()
1870 
 
1871 
  def recv_getBestDeals(self, ):
1872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1873 
    if mtype == TMessageType.EXCEPTION:
1874 
      x = TApplicationException()
1875 
      x.read(self._iprot)
1876 
      self._iprot.readMessageEnd()
1877 
      raise x
1878 
    result = getBestDeals_result()
1879 
    result.read(self._iprot)
1880 
    self._iprot.readMessageEnd()
1881 
    if result.success is not None:
1882 
      return result.success
1883 
    if result.isex is not None:
1884 
      raise result.isex
1885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1886 
 
1887 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1888 
    """
1889 
    Parameters:
1890 
     - beginIndex
1891 
     - totalItems
1892 
     - brand
1893 
     - category
1894 
    """
1895 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1896 
    return self.recv_getBestDealsCatalogIds()
1897 
 
1898 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1899 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1900 
    args = getBestDealsCatalogIds_args()
1901 
    args.beginIndex = beginIndex
1902 
    args.totalItems = totalItems
1903 
    args.brand = brand
1904 
    args.category = category
1905 
    args.write(self._oprot)
1906 
    self._oprot.writeMessageEnd()
1907 
    self._oprot.trans.flush()
1908 
 
1909 
  def recv_getBestDealsCatalogIds(self, ):
1910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1911 
    if mtype == TMessageType.EXCEPTION:
1912 
      x = TApplicationException()
1913 
      x.read(self._iprot)
1914 
      self._iprot.readMessageEnd()
1915 
      raise x
1916 
    result = getBestDealsCatalogIds_result()
1917 
    result.read(self._iprot)
1918 
    self._iprot.readMessageEnd()
1919 
    if result.success is not None:
1920 
      return result.success
1921 
    if result.cex is not None:
1922 
      raise result.cex
1923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1924 
 
1925 
  def getBestDealsCount(self, ):
1926 
    self.send_getBestDealsCount()
1927 
    return self.recv_getBestDealsCount()
1928 
 
1929 
  def send_getBestDealsCount(self, ):
1930 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1931 
    args = getBestDealsCount_args()
1932 
    args.write(self._oprot)
1933 
    self._oprot.writeMessageEnd()
1934 
    self._oprot.trans.flush()
1935 
 
1936 
  def recv_getBestDealsCount(self, ):
1937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1938 
    if mtype == TMessageType.EXCEPTION:
1939 
      x = TApplicationException()
1940 
      x.read(self._iprot)
1941 
      self._iprot.readMessageEnd()
1942 
      raise x
1943 
    result = getBestDealsCount_result()
1944 
    result.read(self._iprot)
1945 
    self._iprot.readMessageEnd()
1946 
    if result.success is not None:
1947 
      return result.success
1948 
    if result.cex is not None:
1949 
      raise result.cex
1950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1951 
 
1952 
  def getComingSoon(self, ):
1953 
    self.send_getComingSoon()
1954 
    return self.recv_getComingSoon()
1955 
 
1956 
  def send_getComingSoon(self, ):
1957 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1958 
    args = getComingSoon_args()
1959 
    args.write(self._oprot)
1960 
    self._oprot.writeMessageEnd()
1961 
    self._oprot.trans.flush()
1962 
 
1963 
  def recv_getComingSoon(self, ):
1964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1965 
    if mtype == TMessageType.EXCEPTION:
1966 
      x = TApplicationException()
1967 
      x.read(self._iprot)
1968 
      self._iprot.readMessageEnd()
1969 
      raise x
1970 
    result = getComingSoon_result()
1971 
    result.read(self._iprot)
1972 
    self._iprot.readMessageEnd()
1973 
    if result.success is not None:
1974 
      return result.success
1975 
    if result.isex is not None:
1976 
      raise result.isex
1977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1978 
 
1979 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1980 
    """
1981 
    Parameters:
1982 
     - beginIndex
1983 
     - totalItems
1984 
     - brand
1985 
     - category
1986 
    """
1987 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1988 
    return self.recv_getComingSoonCatalogIds()
1989 
 
1990 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1991 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1992 
    args = getComingSoonCatalogIds_args()
1993 
    args.beginIndex = beginIndex
1994 
    args.totalItems = totalItems
1995 
    args.brand = brand
1996 
    args.category = category
1997 
    args.write(self._oprot)
1998 
    self._oprot.writeMessageEnd()
1999 
    self._oprot.trans.flush()
2000 
 
2001 
  def recv_getComingSoonCatalogIds(self, ):
2002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2003 
    if mtype == TMessageType.EXCEPTION:
2004 
      x = TApplicationException()
2005 
      x.read(self._iprot)
2006 
      self._iprot.readMessageEnd()
2007 
      raise x
2008 
    result = getComingSoonCatalogIds_result()
2009 
    result.read(self._iprot)
2010 
    self._iprot.readMessageEnd()
2011 
    if result.success is not None:
2012 
      return result.success
2013 
    if result.cex is not None:
2014 
      raise result.cex
2015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
2016 
 
2017 
  def getComingSoonCount(self, ):
2018 
    self.send_getComingSoonCount()
2019 
    return self.recv_getComingSoonCount()
2020 
 
2021 
  def send_getComingSoonCount(self, ):
2022 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
2023 
    args = getComingSoonCount_args()
2024 
    args.write(self._oprot)
2025 
    self._oprot.writeMessageEnd()
2026 
    self._oprot.trans.flush()
2027 
 
2028 
  def recv_getComingSoonCount(self, ):
2029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2030 
    if mtype == TMessageType.EXCEPTION:
2031 
      x = TApplicationException()
2032 
      x.read(self._iprot)
2033 
      self._iprot.readMessageEnd()
2034 
      raise x
2035 
    result = getComingSoonCount_result()
2036 
    result.read(self._iprot)
2037 
    self._iprot.readMessageEnd()
2038 
    if result.success is not None:
2039 
      return result.success
2040 
    if result.cex is not None:
2041 
      raise result.cex
2042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
2043 
 
2044 
  def getLatestArrivals(self, ):
2045 
    """
2046 
    Returns a list of items sorted in the descending order by start date.
2047 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
2048 
    """
2049 
    self.send_getLatestArrivals()
2050 
    return self.recv_getLatestArrivals()
2051 
 
2052 
  def send_getLatestArrivals(self, ):
2053 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
2054 
    args = getLatestArrivals_args()
2055 
    args.write(self._oprot)
2056 
    self._oprot.writeMessageEnd()
2057 
    self._oprot.trans.flush()
2058 
 
2059 
  def recv_getLatestArrivals(self, ):
2060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2061 
    if mtype == TMessageType.EXCEPTION:
2062 
      x = TApplicationException()
2063 
      x.read(self._iprot)
2064 
      self._iprot.readMessageEnd()
2065 
      raise x
2066 
    result = getLatestArrivals_result()
2067 
    result.read(self._iprot)
2068 
    self._iprot.readMessageEnd()
2069 
    if result.success is not None:
2070 
      return result.success
2071 
    if result.isex is not None:
2072 
      raise result.isex
2073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
2074 
 
2075 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2076 
    """
2077 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
2078 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
2079 
 
2080 
    Parameters:
2081 
     - beginIndex
2082 
     - totalItems
2083 
     - brand
2084 
     - categories
2085 
    """
2086 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
2087 
    return self.recv_getLatestArrivalsCatalogIds()
2088 
 
2089 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2090 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
2091 
    args = getLatestArrivalsCatalogIds_args()
2092 
    args.beginIndex = beginIndex
2093 
    args.totalItems = totalItems
2094 
    args.brand = brand
2095 
    args.categories = categories
2096 
    args.write(self._oprot)
2097 
    self._oprot.writeMessageEnd()
2098 
    self._oprot.trans.flush()
2099 
 
2100 
  def recv_getLatestArrivalsCatalogIds(self, ):
2101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2102 
    if mtype == TMessageType.EXCEPTION:
2103 
      x = TApplicationException()
2104 
      x.read(self._iprot)
2105 
      self._iprot.readMessageEnd()
2106 
      raise x
2107 
    result = getLatestArrivalsCatalogIds_result()
2108 
    result.read(self._iprot)
2109 
    self._iprot.readMessageEnd()
2110 
    if result.success is not None:
2111 
      return result.success
2112 
    if result.cex is not None:
2113 
      raise result.cex
2114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
2115 
 
2116 
  def getLatestArrivalsCount(self, ):
2117 
    """
2118 
    Get the total number of latest arrivals we are willing to show.
2119 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
2120 
    """
2121 
    self.send_getLatestArrivalsCount()
2122 
    return self.recv_getLatestArrivalsCount()
2123 
 
2124 
  def send_getLatestArrivalsCount(self, ):
2125 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
2126 
    args = getLatestArrivalsCount_args()
2127 
    args.write(self._oprot)
2128 
    self._oprot.writeMessageEnd()
2129 
    self._oprot.trans.flush()
2130 
 
2131 
  def recv_getLatestArrivalsCount(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 = getLatestArrivalsCount_result()
2139 
    result.read(self._iprot)
2140 
    self._iprot.readMessageEnd()
2141 
    if result.success is not None:
2142 
      return result.success
2143 
    if result.cex is not None:
2144 
      raise result.cex
2145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
2146 
 
2147 
  def generateNewEntityID(self, ):
2148 
    self.send_generateNewEntityID()
2149 
    return self.recv_generateNewEntityID()
2150 
 
2151 
  def send_generateNewEntityID(self, ):
2152 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2153 
    args = generateNewEntityID_args()
2154 
    args.write(self._oprot)
2155 
    self._oprot.writeMessageEnd()
2156 
    self._oprot.trans.flush()
2157 
 
2158 
  def recv_generateNewEntityID(self, ):
2159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2160 
    if mtype == TMessageType.EXCEPTION:
2161 
      x = TApplicationException()
2162 
      x.read(self._iprot)
2163 
      self._iprot.readMessageEnd()
2164 
      raise x
2165 
    result = generateNewEntityID_result()
2166 
    result.read(self._iprot)
2167 
    self._iprot.readMessageEnd()
2168 
    if result.success is not None:
2169 
      return result.success
2170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2171 
 
2172 
  def addCategory(self, category):
2173 
    """
2174 
    All category related functions
2175 
 
2176 
    Parameters:
2177 
     - category
2178 
    """
2179 
    self.send_addCategory(category)
2180 
    return self.recv_addCategory()
2181 
 
2182 
  def send_addCategory(self, category):
2183 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2184 
    args = addCategory_args()
2185 
    args.category = category
2186 
    args.write(self._oprot)
2187 
    self._oprot.writeMessageEnd()
2188 
    self._oprot.trans.flush()
2189 
 
2190 
  def recv_addCategory(self, ):
2191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2192 
    if mtype == TMessageType.EXCEPTION:
2193 
      x = TApplicationException()
2194 
      x.read(self._iprot)
2195 
      self._iprot.readMessageEnd()
2196 
      raise x
2197 
    result = addCategory_result()
2198 
    result.read(self._iprot)
2199 
    self._iprot.readMessageEnd()
2200 
    if result.success is not None:
2201 
      return result.success
2202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2203 
 
2204 
  def getCategory(self, id):
2205 
    """
2206 
    Parameters:
2207 
     - id
2208 
    """
2209 
    self.send_getCategory(id)
2210 
    return self.recv_getCategory()
2211 
 
2212 
  def send_getCategory(self, id):
2213 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2214 
    args = getCategory_args()
2215 
    args.id = id
2216 
    args.write(self._oprot)
2217 
    self._oprot.writeMessageEnd()
2218 
    self._oprot.trans.flush()
2219 
 
2220 
  def recv_getCategory(self, ):
2221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2222 
    if mtype == TMessageType.EXCEPTION:
2223 
      x = TApplicationException()
2224 
      x.read(self._iprot)
2225 
      self._iprot.readMessageEnd()
2226 
      raise x
2227 
    result = getCategory_result()
2228 
    result.read(self._iprot)
2229 
    self._iprot.readMessageEnd()
2230 
    if result.success is not None:
2231 
      return result.success
2232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2233 
 
2234 
  def getAllCategories(self, ):
2235 
    self.send_getAllCategories()
2236 
    return self.recv_getAllCategories()
2237 
 
2238 
  def send_getAllCategories(self, ):
2239 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2240 
    args = getAllCategories_args()
2241 
    args.write(self._oprot)
2242 
    self._oprot.writeMessageEnd()
2243 
    self._oprot.trans.flush()
2244 
 
2245 
  def recv_getAllCategories(self, ):
2246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2247 
    if mtype == TMessageType.EXCEPTION:
2248 
      x = TApplicationException()
2249 
      x.read(self._iprot)
2250 
      self._iprot.readMessageEnd()
2251 
      raise x
2252 
    result = getAllCategories_result()
2253 
    result.read(self._iprot)
2254 
    self._iprot.readMessageEnd()
2255 
    if result.success is not None:
2256 
      return result.success
2257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2258 
 
2259 
  def getAllSimilarItems(self, itemId):
2260 
    """
2261 
    Returns the list of similar items.
2262 
 
2263 
    Parameters:
2264 
     - itemId
2265 
    """
2266 
    self.send_getAllSimilarItems(itemId)
2267 
    return self.recv_getAllSimilarItems()
2268 
 
2269 
  def send_getAllSimilarItems(self, itemId):
2270 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2271 
    args = getAllSimilarItems_args()
2272 
    args.itemId = itemId
2273 
    args.write(self._oprot)
2274 
    self._oprot.writeMessageEnd()
2275 
    self._oprot.trans.flush()
2276 
 
2277 
  def recv_getAllSimilarItems(self, ):
2278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2279 
    if mtype == TMessageType.EXCEPTION:
2280 
      x = TApplicationException()
2281 
      x.read(self._iprot)
2282 
      self._iprot.readMessageEnd()
2283 
      raise x
2284 
    result = getAllSimilarItems_result()
2285 
    result.read(self._iprot)
2286 
    self._iprot.readMessageEnd()
2287 
    if result.success is not None:
2288 
      return result.success
2289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2290 
 
2291 
  def addSimilarItem(self, itemId, catalogItemId):
2292 
    """
2293 
    Adds similar item.
2294 
 
2295 
    Parameters:
2296 
     - itemId
2297 
     - catalogItemId
2298 
    """
2299 
    self.send_addSimilarItem(itemId, catalogItemId)
2300 
    return self.recv_addSimilarItem()
2301 
 
2302 
  def send_addSimilarItem(self, itemId, catalogItemId):
2303 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2304 
    args = addSimilarItem_args()
2305 
    args.itemId = itemId
2306 
    args.catalogItemId = catalogItemId
2307 
    args.write(self._oprot)
2308 
    self._oprot.writeMessageEnd()
2309 
    self._oprot.trans.flush()
2310 
 
2311 
  def recv_addSimilarItem(self, ):
2312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2313 
    if mtype == TMessageType.EXCEPTION:
2314 
      x = TApplicationException()
2315 
      x.read(self._iprot)
2316 
      self._iprot.readMessageEnd()
2317 
      raise x
2318 
    result = addSimilarItem_result()
2319 
    result.read(self._iprot)
2320 
    self._iprot.readMessageEnd()
2321 
    if result.success is not None:
2322 
      return result.success
2323 
    if result.cex is not None:
2324 
      raise result.cex
2325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2326 
 
6512 kshitij.so 2327 
  def addTag(self, displayName, itemId):
2328 
    """
2329 
    Tag Related
2330 
 
2331 
    Parameters:
2332 
     - displayName
2333 
     - itemId
2334 
    """
2335 
    self.send_addTag(displayName, itemId)
2336 
    return self.recv_addTag()
2337 
 
2338 
  def send_addTag(self, displayName, itemId):
2339 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2340 
    args = addTag_args()
2341 
    args.displayName = displayName
2342 
    args.itemId = itemId
2343 
    args.write(self._oprot)
2344 
    self._oprot.writeMessageEnd()
2345 
    self._oprot.trans.flush()
2346 
 
2347 
  def recv_addTag(self, ):
2348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2349 
    if mtype == TMessageType.EXCEPTION:
2350 
      x = TApplicationException()
2351 
      x.read(self._iprot)
2352 
      self._iprot.readMessageEnd()
2353 
      raise x
2354 
    result = addTag_result()
2355 
    result.read(self._iprot)
2356 
    self._iprot.readMessageEnd()
2357 
    if result.success is not None:
2358 
      return result.success
2359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2360 
 
2361 
  def deleteEntityTag(self, displayName, itemId):
2362 
    """
2363 
    Parameters:
2364 
     - displayName
2365 
     - itemId
2366 
    """
2367 
    self.send_deleteEntityTag(displayName, itemId)
2368 
    return self.recv_deleteEntityTag()
2369 
 
2370 
  def send_deleteEntityTag(self, displayName, itemId):
2371 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2372 
    args = deleteEntityTag_args()
2373 
    args.displayName = displayName
2374 
    args.itemId = itemId
2375 
    args.write(self._oprot)
2376 
    self._oprot.writeMessageEnd()
2377 
    self._oprot.trans.flush()
2378 
 
2379 
  def recv_deleteEntityTag(self, ):
2380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2381 
    if mtype == TMessageType.EXCEPTION:
2382 
      x = TApplicationException()
2383 
      x.read(self._iprot)
2384 
      self._iprot.readMessageEnd()
2385 
      raise x
2386 
    result = deleteEntityTag_result()
2387 
    result.read(self._iprot)
2388 
    self._iprot.readMessageEnd()
2389 
    if result.success is not None:
2390 
      return result.success
2391 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2392 
 
2393 
  def deleteTag(self, displayName):
2394 
    """
2395 
    Parameters:
2396 
     - displayName
2397 
    """
2398 
    self.send_deleteTag(displayName)
2399 
    return self.recv_deleteTag()
2400 
 
2401 
  def send_deleteTag(self, displayName):
2402 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2403 
    args = deleteTag_args()
2404 
    args.displayName = displayName
2405 
    args.write(self._oprot)
2406 
    self._oprot.writeMessageEnd()
2407 
    self._oprot.trans.flush()
2408 
 
2409 
  def recv_deleteTag(self, ):
2410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2411 
    if mtype == TMessageType.EXCEPTION:
2412 
      x = TApplicationException()
2413 
      x.read(self._iprot)
2414 
      self._iprot.readMessageEnd()
2415 
      raise x
2416 
    result = deleteTag_result()
2417 
    result.read(self._iprot)
2418 
    self._iprot.readMessageEnd()
2419 
    if result.success is not None:
2420 
      return result.success
2421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2422 
 
2423 
  def getAllTags(self, ):
2424 
    self.send_getAllTags()
2425 
    return self.recv_getAllTags()
2426 
 
2427 
  def send_getAllTags(self, ):
2428 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2429 
    args = getAllTags_args()
2430 
    args.write(self._oprot)
2431 
    self._oprot.writeMessageEnd()
2432 
    self._oprot.trans.flush()
2433 
 
2434 
  def recv_getAllTags(self, ):
2435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2436 
    if mtype == TMessageType.EXCEPTION:
2437 
      x = TApplicationException()
2438 
      x.read(self._iprot)
2439 
      self._iprot.readMessageEnd()
2440 
      raise x
2441 
    result = getAllTags_result()
2442 
    result.read(self._iprot)
2443 
    self._iprot.readMessageEnd()
2444 
    if result.success is not None:
2445 
      return result.success
2446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2447 
 
2448 
  def getAllEntitiesByTagName(self, displayName):
2449 
    """
2450 
    Parameters:
2451 
     - displayName
2452 
    """
2453 
    self.send_getAllEntitiesByTagName(displayName)
2454 
    return self.recv_getAllEntitiesByTagName()
2455 
 
2456 
  def send_getAllEntitiesByTagName(self, displayName):
2457 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2458 
    args = getAllEntitiesByTagName_args()
2459 
    args.displayName = displayName
2460 
    args.write(self._oprot)
2461 
    self._oprot.writeMessageEnd()
2462 
    self._oprot.trans.flush()
2463 
 
2464 
  def recv_getAllEntitiesByTagName(self, ):
2465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2466 
    if mtype == TMessageType.EXCEPTION:
2467 
      x = TApplicationException()
2468 
      x.read(self._iprot)
2469 
      self._iprot.readMessageEnd()
2470 
      raise x
2471 
    result = getAllEntitiesByTagName_result()
2472 
    result.read(self._iprot)
2473 
    self._iprot.readMessageEnd()
2474 
    if result.success is not None:
2475 
      return result.success
2476 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2477 
 
6845 amit.gupta 2478 
  def getAllEntityTags(self, ):
2479 
    self.send_getAllEntityTags()
2480 
    return self.recv_getAllEntityTags()
2481 
 
2482 
  def send_getAllEntityTags(self, ):
2483 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2484 
    args = getAllEntityTags_args()
2485 
    args.write(self._oprot)
2486 
    self._oprot.writeMessageEnd()
2487 
    self._oprot.trans.flush()
2488 
 
2489 
  def recv_getAllEntityTags(self, ):
2490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2491 
    if mtype == TMessageType.EXCEPTION:
2492 
      x = TApplicationException()
2493 
      x.read(self._iprot)
2494 
      self._iprot.readMessageEnd()
2495 
      raise x
2496 
    result = getAllEntityTags_result()
2497 
    result.read(self._iprot)
2498 
    self._iprot.readMessageEnd()
2499 
    if result.success is not None:
2500 
      return result.success
2501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2502 
 
8590 kshitij.so 2503 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2504 
    """
8579 kshitij.so 2505 
    Banner Related
2506 
 
6850 kshitij.so 2507 
    Parameters:
8590 kshitij.so 2508 
     - bannerCongregate
6850 kshitij.so 2509 
    """
8590 kshitij.so 2510 
    self.send_addBanner(bannerCongregate)
10097 kshitij.so 2511 
    return self.recv_addBanner()
6850 kshitij.so 2512 
 
8590 kshitij.so 2513 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2514 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2515 
    args = addBanner_args()
8590 kshitij.so 2516 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2517 
    args.write(self._oprot)
2518 
    self._oprot.writeMessageEnd()
2519 
    self._oprot.trans.flush()
2520 
 
2521 
  def recv_addBanner(self, ):
2522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2523 
    if mtype == TMessageType.EXCEPTION:
2524 
      x = TApplicationException()
2525 
      x.read(self._iprot)
2526 
      self._iprot.readMessageEnd()
2527 
      raise x
2528 
    result = addBanner_result()
2529 
    result.read(self._iprot)
2530 
    self._iprot.readMessageEnd()
10097 kshitij.so 2531 
    if result.success is not None:
2532 
      return result.success
2533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
6850 kshitij.so 2534 
 
8579 kshitij.so 2535 
  def updateBanner(self, banner):
2536 
    """
2537 
    Parameters:
2538 
     - banner
2539 
    """
2540 
    self.send_updateBanner(banner)
2541 
    return self.recv_updateBanner()
2542 
 
2543 
  def send_updateBanner(self, banner):
2544 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2545 
    args = updateBanner_args()
2546 
    args.banner = banner
2547 
    args.write(self._oprot)
2548 
    self._oprot.writeMessageEnd()
2549 
    self._oprot.trans.flush()
2550 
 
2551 
  def recv_updateBanner(self, ):
2552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2553 
    if mtype == TMessageType.EXCEPTION:
2554 
      x = TApplicationException()
2555 
      x.read(self._iprot)
2556 
      self._iprot.readMessageEnd()
2557 
      raise x
2558 
    result = updateBanner_result()
2559 
    result.read(self._iprot)
2560 
    self._iprot.readMessageEnd()
2561 
    if result.success is not None:
2562 
      return result.success
2563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2564 
 
6850 kshitij.so 2565 
  def getAllBanners(self, ):
2566 
    self.send_getAllBanners()
2567 
    return self.recv_getAllBanners()
2568 
 
2569 
  def send_getAllBanners(self, ):
2570 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2571 
    args = getAllBanners_args()
2572 
    args.write(self._oprot)
2573 
    self._oprot.writeMessageEnd()
2574 
    self._oprot.trans.flush()
2575 
 
2576 
  def recv_getAllBanners(self, ):
2577 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2578 
    if mtype == TMessageType.EXCEPTION:
2579 
      x = TApplicationException()
2580 
      x.read(self._iprot)
2581 
      self._iprot.readMessageEnd()
2582 
      raise x
2583 
    result = getAllBanners_result()
2584 
    result.read(self._iprot)
2585 
    self._iprot.readMessageEnd()
2586 
    if result.success is not None:
2587 
      return result.success
2588 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2589 
 
9155 kshitij.so 2590 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2591 
    """
2592 
    Parameters:
2593 
     - bannerName
9155 kshitij.so 2594 
     - bannerType
6850 kshitij.so 2595 
    """
9155 kshitij.so 2596 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2597 
    return self.recv_deleteBanner()
2598 
 
9155 kshitij.so 2599 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2600 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2601 
    args = deleteBanner_args()
2602 
    args.bannerName = bannerName
9155 kshitij.so 2603 
    args.bannerType = bannerType
6850 kshitij.so 2604 
    args.write(self._oprot)
2605 
    self._oprot.writeMessageEnd()
2606 
    self._oprot.trans.flush()
2607 
 
2608 
  def recv_deleteBanner(self, ):
2609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2610 
    if mtype == TMessageType.EXCEPTION:
2611 
      x = TApplicationException()
2612 
      x.read(self._iprot)
2613 
      self._iprot.readMessageEnd()
2614 
      raise x
2615 
    result = deleteBanner_result()
2616 
    result.read(self._iprot)
2617 
    self._iprot.readMessageEnd()
2618 
    if result.success is not None:
2619 
      return result.success
2620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2621 
 
9155 kshitij.so 2622 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2623 
    """
2624 
    Parameters:
2625 
     - bannerName
9155 kshitij.so 2626 
     - bannerType
6850 kshitij.so 2627 
    """
9155 kshitij.so 2628 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2629 
    return self.recv_getBannerDetails()
2630 
 
9155 kshitij.so 2631 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2632 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2633 
    args = getBannerDetails_args()
2634 
    args.bannerName = bannerName
9155 kshitij.so 2635 
    args.bannerType = bannerType
6850 kshitij.so 2636 
    args.write(self._oprot)
2637 
    self._oprot.writeMessageEnd()
2638 
    self._oprot.trans.flush()
2639 
 
2640 
  def recv_getBannerDetails(self, ):
2641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2642 
    if mtype == TMessageType.EXCEPTION:
2643 
      x = TApplicationException()
2644 
      x.read(self._iprot)
2645 
      self._iprot.readMessageEnd()
2646 
      raise x
2647 
    result = getBannerDetails_result()
2648 
    result.read(self._iprot)
2649 
    self._iprot.readMessageEnd()
2650 
    if result.success is not None:
2651 
      return result.success
2652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2653 
 
2654 
  def getActiveBanners(self, ):
2655 
    self.send_getActiveBanners()
2656 
    return self.recv_getActiveBanners()
2657 
 
2658 
  def send_getActiveBanners(self, ):
2659 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2660 
    args = getActiveBanners_args()
2661 
    args.write(self._oprot)
2662 
    self._oprot.writeMessageEnd()
2663 
    self._oprot.trans.flush()
2664 
 
2665 
  def recv_getActiveBanners(self, ):
2666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2667 
    if mtype == TMessageType.EXCEPTION:
2668 
      x = TApplicationException()
2669 
      x.read(self._iprot)
2670 
      self._iprot.readMessageEnd()
2671 
      raise x
2672 
    result = getActiveBanners_result()
2673 
    result.read(self._iprot)
2674 
    self._iprot.readMessageEnd()
2675 
    if result.success is not None:
2676 
      return result.success
2677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2678 
 
8579 kshitij.so 2679 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2680 
    """
2681 
    Parameters:
8579 kshitij.so 2682 
     - bannerMaps
6849 kshitij.so 2683 
    """
8579 kshitij.so 2684 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2685 
    return self.recv_addBannerMap()
2686 
 
8579 kshitij.so 2687 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2688 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2689 
    args = addBannerMap_args()
8579 kshitij.so 2690 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2691 
    args.write(self._oprot)
2692 
    self._oprot.writeMessageEnd()
2693 
    self._oprot.trans.flush()
2694 
 
2695 
  def recv_addBannerMap(self, ):
2696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2697 
    if mtype == TMessageType.EXCEPTION:
2698 
      x = TApplicationException()
2699 
      x.read(self._iprot)
2700 
      self._iprot.readMessageEnd()
2701 
      raise x
2702 
    result = addBannerMap_result()
2703 
    result.read(self._iprot)
2704 
    self._iprot.readMessageEnd()
2705 
    if result.success is not None:
2706 
      return result.success
2707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2708 
 
8579 kshitij.so 2709 
  def updateBannerMap(self, bannerMap):
2710 
    """
2711 
    Parameters:
2712 
     - bannerMap
2713 
    """
2714 
    self.send_updateBannerMap(bannerMap)
2715 
    return self.recv_updateBannerMap()
2716 
 
2717 
  def send_updateBannerMap(self, bannerMap):
2718 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2719 
    args = updateBannerMap_args()
2720 
    args.bannerMap = bannerMap
2721 
    args.write(self._oprot)
2722 
    self._oprot.writeMessageEnd()
2723 
    self._oprot.trans.flush()
2724 
 
2725 
  def recv_updateBannerMap(self, ):
2726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2727 
    if mtype == TMessageType.EXCEPTION:
2728 
      x = TApplicationException()
2729 
      x.read(self._iprot)
2730 
      self._iprot.readMessageEnd()
2731 
      raise x
2732 
    result = updateBannerMap_result()
2733 
    result.read(self._iprot)
2734 
    self._iprot.readMessageEnd()
2735 
    if result.success is not None:
2736 
      return result.success
2737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2738 
 
6849 kshitij.so 2739 
  def deleteBannerMap(self, bannerName):
2740 
    """
2741 
    Parameters:
2742 
     - bannerName
2743 
    """
2744 
    self.send_deleteBannerMap(bannerName)
2745 
    return self.recv_deleteBannerMap()
2746 
 
2747 
  def send_deleteBannerMap(self, bannerName):
2748 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2749 
    args = deleteBannerMap_args()
2750 
    args.bannerName = bannerName
2751 
    args.write(self._oprot)
2752 
    self._oprot.writeMessageEnd()
2753 
    self._oprot.trans.flush()
2754 
 
2755 
  def recv_deleteBannerMap(self, ):
2756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2757 
    if mtype == TMessageType.EXCEPTION:
2758 
      x = TApplicationException()
2759 
      x.read(self._iprot)
2760 
      self._iprot.readMessageEnd()
2761 
      raise x
2762 
    result = deleteBannerMap_result()
2763 
    result.read(self._iprot)
2764 
    self._iprot.readMessageEnd()
2765 
    if result.success is not None:
2766 
      return result.success
2767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2768 
 
9155 kshitij.so 2769 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2770 
    """
2771 
    Parameters:
2772 
     - bannerName
9155 kshitij.so 2773 
     - bannerType
6849 kshitij.so 2774 
    """
9155 kshitij.so 2775 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2776 
    return self.recv_getBannerMapDetails()
2777 
 
9155 kshitij.so 2778 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2779 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2780 
    args = getBannerMapDetails_args()
2781 
    args.bannerName = bannerName
9155 kshitij.so 2782 
    args.bannerType = bannerType
6849 kshitij.so 2783 
    args.write(self._oprot)
2784 
    self._oprot.writeMessageEnd()
2785 
    self._oprot.trans.flush()
2786 
 
2787 
  def recv_getBannerMapDetails(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 = getBannerMapDetails_result()
2795 
    result.read(self._iprot)
2796 
    self._iprot.readMessageEnd()
2797 
    if result.success is not None:
2798 
      return result.success
2799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2800 
 
8579 kshitij.so 2801 
  def addBannerUri(self, bannerUriMappings):
2802 
    """
2803 
    Parameters:
2804 
     - bannerUriMappings
2805 
    """
2806 
    self.send_addBannerUri(bannerUriMappings)
2807 
    self.recv_addBannerUri()
2808 
 
2809 
  def send_addBannerUri(self, bannerUriMappings):
2810 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2811 
    args = addBannerUri_args()
2812 
    args.bannerUriMappings = bannerUriMappings
2813 
    args.write(self._oprot)
2814 
    self._oprot.writeMessageEnd()
2815 
    self._oprot.trans.flush()
2816 
 
2817 
  def recv_addBannerUri(self, ):
2818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2819 
    if mtype == TMessageType.EXCEPTION:
2820 
      x = TApplicationException()
2821 
      x.read(self._iprot)
2822 
      self._iprot.readMessageEnd()
2823 
      raise x
2824 
    result = addBannerUri_result()
2825 
    result.read(self._iprot)
2826 
    self._iprot.readMessageEnd()
2827 
    return
2828 
 
9155 kshitij.so 2829 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2830 
    """
2831 
    Parameters:
2832 
     - bannerName
9155 kshitij.so 2833 
     - bannerType
8579 kshitij.so 2834 
    """
9155 kshitij.so 2835 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2836 
    return self.recv_getUriMapping()
2837 
 
9155 kshitij.so 2838 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2839 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2840 
    args = getUriMapping_args()
2841 
    args.bannerName = bannerName
9155 kshitij.so 2842 
    args.bannerType = bannerType
8579 kshitij.so 2843 
    args.write(self._oprot)
2844 
    self._oprot.writeMessageEnd()
2845 
    self._oprot.trans.flush()
2846 
 
2847 
  def recv_getUriMapping(self, ):
2848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2849 
    if mtype == TMessageType.EXCEPTION:
2850 
      x = TApplicationException()
2851 
      x.read(self._iprot)
2852 
      self._iprot.readMessageEnd()
2853 
      raise x
2854 
    result = getUriMapping_result()
2855 
    result.read(self._iprot)
2856 
    self._iprot.readMessageEnd()
2857 
    if result.success is not None:
2858 
      return result.success
2859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2860 
 
2861 
  def addCampaign(self, campaign):
2862 
    """
2863 
    Parameters:
2864 
     - campaign
2865 
    """
2866 
    self.send_addCampaign(campaign)
2867 
    self.recv_addCampaign()
2868 
 
2869 
  def send_addCampaign(self, campaign):
2870 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2871 
    args = addCampaign_args()
2872 
    args.campaign = campaign
2873 
    args.write(self._oprot)
2874 
    self._oprot.writeMessageEnd()
2875 
    self._oprot.trans.flush()
2876 
 
2877 
  def recv_addCampaign(self, ):
2878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2879 
    if mtype == TMessageType.EXCEPTION:
2880 
      x = TApplicationException()
2881 
      x.read(self._iprot)
2882 
      self._iprot.readMessageEnd()
2883 
      raise x
2884 
    result = addCampaign_result()
2885 
    result.read(self._iprot)
2886 
    self._iprot.readMessageEnd()
2887 
    return
2888 
 
2889 
  def getCampaigns(self, campaignName):
2890 
    """
2891 
    Parameters:
2892 
     - campaignName
2893 
    """
2894 
    self.send_getCampaigns(campaignName)
2895 
    return self.recv_getCampaigns()
2896 
 
2897 
  def send_getCampaigns(self, campaignName):
2898 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2899 
    args = getCampaigns_args()
2900 
    args.campaignName = campaignName
2901 
    args.write(self._oprot)
2902 
    self._oprot.writeMessageEnd()
2903 
    self._oprot.trans.flush()
2904 
 
2905 
  def recv_getCampaigns(self, ):
2906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2907 
    if mtype == TMessageType.EXCEPTION:
2908 
      x = TApplicationException()
2909 
      x.read(self._iprot)
2910 
      self._iprot.readMessageEnd()
2911 
      raise x
2912 
    result = getCampaigns_result()
2913 
    result.read(self._iprot)
2914 
    self._iprot.readMessageEnd()
2915 
    if result.success is not None:
2916 
      return result.success
2917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2918 
 
2919 
  def deleteCampaign(self, campaignId):
2920 
    """
2921 
    Parameters:
2922 
     - campaignId
2923 
    """
2924 
    self.send_deleteCampaign(campaignId)
2925 
    self.recv_deleteCampaign()
2926 
 
2927 
  def send_deleteCampaign(self, campaignId):
2928 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2929 
    args = deleteCampaign_args()
2930 
    args.campaignId = campaignId
2931 
    args.write(self._oprot)
2932 
    self._oprot.writeMessageEnd()
2933 
    self._oprot.trans.flush()
2934 
 
2935 
  def recv_deleteCampaign(self, ):
2936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2937 
    if mtype == TMessageType.EXCEPTION:
2938 
      x = TApplicationException()
2939 
      x.read(self._iprot)
2940 
      self._iprot.readMessageEnd()
2941 
      raise x
2942 
    result = deleteCampaign_result()
2943 
    result.read(self._iprot)
2944 
    self._iprot.readMessageEnd()
2945 
    return
2946 
 
2947 
  def getAllCampaigns(self, ):
2948 
    self.send_getAllCampaigns()
2949 
    return self.recv_getAllCampaigns()
2950 
 
2951 
  def send_getAllCampaigns(self, ):
2952 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2953 
    args = getAllCampaigns_args()
2954 
    args.write(self._oprot)
2955 
    self._oprot.writeMessageEnd()
2956 
    self._oprot.trans.flush()
2957 
 
2958 
  def recv_getAllCampaigns(self, ):
2959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2960 
    if mtype == TMessageType.EXCEPTION:
2961 
      x = TApplicationException()
2962 
      x.read(self._iprot)
2963 
      self._iprot.readMessageEnd()
2964 
      raise x
2965 
    result = getAllCampaigns_result()
2966 
    result.read(self._iprot)
2967 
    self._iprot.readMessageEnd()
2968 
    if result.success is not None:
2969 
      return result.success
2970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2971 
 
9155 kshitij.so 2972 
  def getActiveBannersForMobileSite(self, ):
2973 
    self.send_getActiveBannersForMobileSite()
2974 
    return self.recv_getActiveBannersForMobileSite()
2975 
 
2976 
  def send_getActiveBannersForMobileSite(self, ):
2977 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2978 
    args = getActiveBannersForMobileSite_args()
2979 
    args.write(self._oprot)
2980 
    self._oprot.writeMessageEnd()
2981 
    self._oprot.trans.flush()
2982 
 
2983 
  def recv_getActiveBannersForMobileSite(self, ):
2984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2985 
    if mtype == TMessageType.EXCEPTION:
2986 
      x = TApplicationException()
2987 
      x.read(self._iprot)
2988 
      self._iprot.readMessageEnd()
2989 
      raise x
2990 
    result = getActiveBannersForMobileSite_result()
2991 
    result.read(self._iprot)
2992 
    self._iprot.readMessageEnd()
2993 
    if result.success is not None:
2994 
      return result.success
2995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2996 
 
5944 mandeep.dh 2997 
  def deleteSimilarItem(self, itemId, catalogItemId):
2998 
    """
2999 
    Delete similar item.
3000 
 
3001 
    Parameters:
3002 
     - itemId
3003 
     - catalogItemId
3004 
    """
3005 
    self.send_deleteSimilarItem(itemId, catalogItemId)
3006 
    return self.recv_deleteSimilarItem()
3007 
 
3008 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
3009 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
3010 
    args = deleteSimilarItem_args()
3011 
    args.itemId = itemId
3012 
    args.catalogItemId = catalogItemId
3013 
    args.write(self._oprot)
3014 
    self._oprot.writeMessageEnd()
3015 
    self._oprot.trans.flush()
3016 
 
3017 
  def recv_deleteSimilarItem(self, ):
3018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3019 
    if mtype == TMessageType.EXCEPTION:
3020 
      x = TApplicationException()
3021 
      x.read(self._iprot)
3022 
      self._iprot.readMessageEnd()
3023 
      raise x
3024 
    result = deleteSimilarItem_result()
3025 
    result.read(self._iprot)
3026 
    self._iprot.readMessageEnd()
3027 
    if result.success is not None:
3028 
      return result.success
3029 
    if result.cex is not None:
3030 
      raise result.cex
3031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
3032 
 
3033 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
3034 
    """
3035 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
3036 
    If yes, returns the itemId else returns 0
3037 
 
3038 
    Parameters:
3039 
     - brand
3040 
     - modelNumber
3041 
     - modelName
3042 
     - color
3043 
    """
3044 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
3045 
    return self.recv_checkSimilarItem()
3046 
 
3047 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
3048 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
3049 
    args = checkSimilarItem_args()
3050 
    args.brand = brand
3051 
    args.modelNumber = modelNumber
3052 
    args.modelName = modelName
3053 
    args.color = color
3054 
    args.write(self._oprot)
3055 
    self._oprot.writeMessageEnd()
3056 
    self._oprot.trans.flush()
3057 
 
3058 
  def recv_checkSimilarItem(self, ):
3059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3060 
    if mtype == TMessageType.EXCEPTION:
3061 
      x = TApplicationException()
3062 
      x.read(self._iprot)
3063 
      self._iprot.readMessageEnd()
3064 
      raise x
3065 
    result = checkSimilarItem_result()
3066 
    result.read(self._iprot)
3067 
    self._iprot.readMessageEnd()
3068 
    if result.success is not None:
3069 
      return result.success
3070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
3071 
 
3072 
  def validateRiskyStatus(self, itemId):
3073 
    """
3074 
    Check wether item is risky and change status if inventory is not available for risky items
3075 
 
3076 
    Parameters:
3077 
     - itemId
3078 
    """
3079 
    self.send_validateRiskyStatus(itemId)
3080 
    self.recv_validateRiskyStatus()
3081 
 
3082 
  def send_validateRiskyStatus(self, itemId):
3083 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
3084 
    args = validateRiskyStatus_args()
3085 
    args.itemId = itemId
3086 
    args.write(self._oprot)
3087 
    self._oprot.writeMessageEnd()
3088 
    self._oprot.trans.flush()
3089 
 
3090 
  def recv_validateRiskyStatus(self, ):
3091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3092 
    if mtype == TMessageType.EXCEPTION:
3093 
      x = TApplicationException()
3094 
      x.read(self._iprot)
3095 
      self._iprot.readMessageEnd()
3096 
      raise x
3097 
    result = validateRiskyStatus_result()
3098 
    result.read(self._iprot)
3099 
    self._iprot.readMessageEnd()
3100 
    return
3101 
 
3102 
  def changeItemRiskyFlag(self, itemId, risky):
3103 
    """
3104 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
3105 
 
3106 
    Parameters:
3107 
     - itemId
3108 
     - risky
3109 
    """
3110 
    self.send_changeItemRiskyFlag(itemId, risky)
3111 
    self.recv_changeItemRiskyFlag()
3112 
 
3113 
  def send_changeItemRiskyFlag(self, itemId, risky):
3114 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
3115 
    args = changeItemRiskyFlag_args()
3116 
    args.itemId = itemId
3117 
    args.risky = risky
3118 
    args.write(self._oprot)
3119 
    self._oprot.writeMessageEnd()
3120 
    self._oprot.trans.flush()
3121 
 
3122 
  def recv_changeItemRiskyFlag(self, ):
3123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3124 
    if mtype == TMessageType.EXCEPTION:
3125 
      x = TApplicationException()
3126 
      x.read(self._iprot)
3127 
      self._iprot.readMessageEnd()
3128 
      raise x
3129 
    result = changeItemRiskyFlag_result()
3130 
    result.read(self._iprot)
3131 
    self._iprot.readMessageEnd()
3132 
    return
3133 
 
3134 
  def getItemsByRiskyFlag(self, ):
3135 
    """
3136 
    Returns list of items marked as risky.
3137 
    """
3138 
    self.send_getItemsByRiskyFlag()
3139 
    return self.recv_getItemsByRiskyFlag()
3140 
 
3141 
  def send_getItemsByRiskyFlag(self, ):
3142 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
3143 
    args = getItemsByRiskyFlag_args()
3144 
    args.write(self._oprot)
3145 
    self._oprot.writeMessageEnd()
3146 
    self._oprot.trans.flush()
3147 
 
3148 
  def recv_getItemsByRiskyFlag(self, ):
3149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3150 
    if mtype == TMessageType.EXCEPTION:
3151 
      x = TApplicationException()
3152 
      x.read(self._iprot)
3153 
      self._iprot.readMessageEnd()
3154 
      raise x
3155 
    result = getItemsByRiskyFlag_result()
3156 
    result.read(self._iprot)
3157 
    self._iprot.readMessageEnd()
3158 
    if result.success is not None:
3159 
      return result.success
3160 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
3161 
 
3162 
  def getItemsForMasterSheet(self, category, brand):
3163 
    """
3164 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3165 
 
3166 
    Parameters:
3167 
     - category
3168 
     - brand
3169 
    """
3170 
    self.send_getItemsForMasterSheet(category, brand)
3171 
    return self.recv_getItemsForMasterSheet()
3172 
 
3173 
  def send_getItemsForMasterSheet(self, category, brand):
3174 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3175 
    args = getItemsForMasterSheet_args()
3176 
    args.category = category
3177 
    args.brand = brand
3178 
    args.write(self._oprot)
3179 
    self._oprot.writeMessageEnd()
3180 
    self._oprot.trans.flush()
3181 
 
3182 
  def recv_getItemsForMasterSheet(self, ):
3183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3184 
    if mtype == TMessageType.EXCEPTION:
3185 
      x = TApplicationException()
3186 
      x.read(self._iprot)
3187 
      self._iprot.readMessageEnd()
3188 
      raise x
3189 
    result = getItemsForMasterSheet_result()
3190 
    result.read(self._iprot)
3191 
    self._iprot.readMessageEnd()
3192 
    if result.success is not None:
3193 
      return result.success
3194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3195 
 
3196 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3197 
    """
3198 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3199 
 
3200 
    Parameters:
3201 
     - beginIndex
3202 
     - totalItems
3203 
     - itemId
3204 
    """
3205 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3206 
    return self.recv_getSimilarItemsCatalogIds()
3207 
 
3208 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3209 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3210 
    args = getSimilarItemsCatalogIds_args()
3211 
    args.beginIndex = beginIndex
3212 
    args.totalItems = totalItems
3213 
    args.itemId = itemId
3214 
    args.write(self._oprot)
3215 
    self._oprot.writeMessageEnd()
3216 
    self._oprot.trans.flush()
3217 
 
3218 
  def recv_getSimilarItemsCatalogIds(self, ):
3219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3220 
    if mtype == TMessageType.EXCEPTION:
3221 
      x = TApplicationException()
3222 
      x.read(self._iprot)
3223 
      self._iprot.readMessageEnd()
3224 
      raise x
3225 
    result = getSimilarItemsCatalogIds_result()
3226 
    result.read(self._iprot)
3227 
    self._iprot.readMessageEnd()
3228 
    if result.success is not None:
3229 
      return result.success
3230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3231 
 
3232 
  def addProductNotification(self, itemId, email):
3233 
    """
3234 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3235 
 
3236 
    Parameters:
3237 
     - itemId
3238 
     - email
3239 
    """
3240 
    self.send_addProductNotification(itemId, email)
3241 
    return self.recv_addProductNotification()
3242 
 
3243 
  def send_addProductNotification(self, itemId, email):
3244 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3245 
    args = addProductNotification_args()
3246 
    args.itemId = itemId
3247 
    args.email = email
3248 
    args.write(self._oprot)
3249 
    self._oprot.writeMessageEnd()
3250 
    self._oprot.trans.flush()
3251 
 
3252 
  def recv_addProductNotification(self, ):
3253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3254 
    if mtype == TMessageType.EXCEPTION:
3255 
      x = TApplicationException()
3256 
      x.read(self._iprot)
3257 
      self._iprot.readMessageEnd()
3258 
      raise x
3259 
    result = addProductNotification_result()
3260 
    result.read(self._iprot)
3261 
    self._iprot.readMessageEnd()
3262 
    if result.success is not None:
3263 
      return result.success
3264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3265 
 
3266 
  def sendProductNotifications(self, ):
3267 
    """
3268 
    Send the product notifications to the users for items which has stock.
3269 
    """
3270 
    self.send_sendProductNotifications()
3271 
    return self.recv_sendProductNotifications()
3272 
 
3273 
  def send_sendProductNotifications(self, ):
3274 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3275 
    args = sendProductNotifications_args()
3276 
    args.write(self._oprot)
3277 
    self._oprot.writeMessageEnd()
3278 
    self._oprot.trans.flush()
3279 
 
3280 
  def recv_sendProductNotifications(self, ):
3281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3282 
    if mtype == TMessageType.EXCEPTION:
3283 
      x = TApplicationException()
3284 
      x.read(self._iprot)
3285 
      self._iprot.readMessageEnd()
3286 
      raise x
3287 
    result = sendProductNotifications_result()
3288 
    result.read(self._iprot)
3289 
    self._iprot.readMessageEnd()
3290 
    if result.success is not None:
3291 
      return result.success
3292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3293 
 
3294 
  def getAllBrandsByCategory(self, categoryId):
3295 
    """
3296 
    Returns list of brand names for a given category Id
3297 
 
3298 
    Parameters:
3299 
     - categoryId
3300 
    """
3301 
    self.send_getAllBrandsByCategory(categoryId)
3302 
    return self.recv_getAllBrandsByCategory()
3303 
 
3304 
  def send_getAllBrandsByCategory(self, categoryId):
3305 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3306 
    args = getAllBrandsByCategory_args()
3307 
    args.categoryId = categoryId
3308 
    args.write(self._oprot)
3309 
    self._oprot.writeMessageEnd()
3310 
    self._oprot.trans.flush()
3311 
 
3312 
  def recv_getAllBrandsByCategory(self, ):
3313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3314 
    if mtype == TMessageType.EXCEPTION:
3315 
      x = TApplicationException()
3316 
      x.read(self._iprot)
3317 
      self._iprot.readMessageEnd()
3318 
      raise x
3319 
    result = getAllBrandsByCategory_result()
3320 
    result.read(self._iprot)
3321 
    self._iprot.readMessageEnd()
3322 
    if result.success is not None:
3323 
      return result.success
3324 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3325 
 
3326 
  def getAllBrands(self, ):
3327 
    """
3328 
    Returns list of brand names
3329 
    """
3330 
    self.send_getAllBrands()
3331 
    return self.recv_getAllBrands()
3332 
 
3333 
  def send_getAllBrands(self, ):
3334 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3335 
    args = getAllBrands_args()
3336 
    args.write(self._oprot)
3337 
    self._oprot.writeMessageEnd()
3338 
    self._oprot.trans.flush()
3339 
 
3340 
  def recv_getAllBrands(self, ):
3341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3342 
    if mtype == TMessageType.EXCEPTION:
3343 
      x = TApplicationException()
3344 
      x.read(self._iprot)
3345 
      self._iprot.readMessageEnd()
3346 
      raise x
3347 
    result = getAllBrands_result()
3348 
    result.read(self._iprot)
3349 
    self._iprot.readMessageEnd()
3350 
    if result.success is not None:
3351 
      return result.success
3352 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3353 
 
3354 
  def getAllSources(self, ):
3355 
    """
3356 
    Return list of all sources
3357 
    """
3358 
    self.send_getAllSources()
3359 
    return self.recv_getAllSources()
3360 
 
3361 
  def send_getAllSources(self, ):
3362 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3363 
    args = getAllSources_args()
3364 
    args.write(self._oprot)
3365 
    self._oprot.writeMessageEnd()
3366 
    self._oprot.trans.flush()
3367 
 
3368 
  def recv_getAllSources(self, ):
3369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3370 
    if mtype == TMessageType.EXCEPTION:
3371 
      x = TApplicationException()
3372 
      x.read(self._iprot)
3373 
      self._iprot.readMessageEnd()
3374 
      raise x
3375 
    result = getAllSources_result()
3376 
    result.read(self._iprot)
3377 
    self._iprot.readMessageEnd()
3378 
    if result.success is not None:
3379 
      return result.success
3380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3381 
 
3382 
  def getItemPricingBySource(self, itemId, sourceId):
3383 
    """
3384 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3385 
 
3386 
    Parameters:
3387 
     - itemId
3388 
     - sourceId
3389 
    """
3390 
    self.send_getItemPricingBySource(itemId, sourceId)
3391 
    return self.recv_getItemPricingBySource()
3392 
 
3393 
  def send_getItemPricingBySource(self, itemId, sourceId):
3394 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3395 
    args = getItemPricingBySource_args()
3396 
    args.itemId = itemId
3397 
    args.sourceId = sourceId
3398 
    args.write(self._oprot)
3399 
    self._oprot.writeMessageEnd()
3400 
    self._oprot.trans.flush()
3401 
 
3402 
  def recv_getItemPricingBySource(self, ):
3403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3404 
    if mtype == TMessageType.EXCEPTION:
3405 
      x = TApplicationException()
3406 
      x.read(self._iprot)
3407 
      self._iprot.readMessageEnd()
3408 
      raise x
3409 
    result = getItemPricingBySource_result()
3410 
    result.read(self._iprot)
3411 
    self._iprot.readMessageEnd()
3412 
    if result.success is not None:
3413 
      return result.success
3414 
    if result.cex is not None:
3415 
      raise result.cex
3416 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3417 
 
3418 
  def addSourceItemPricing(self, sourceItemPricing):
3419 
    """
3420 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3421 
    If item is not found or source is not found, it will throw exception.
3422 
 
3423 
    Parameters:
3424 
     - sourceItemPricing
3425 
    """
3426 
    self.send_addSourceItemPricing(sourceItemPricing)
3427 
    self.recv_addSourceItemPricing()
3428 
 
3429 
  def send_addSourceItemPricing(self, sourceItemPricing):
3430 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3431 
    args = addSourceItemPricing_args()
3432 
    args.sourceItemPricing = sourceItemPricing
3433 
    args.write(self._oprot)
3434 
    self._oprot.writeMessageEnd()
3435 
    self._oprot.trans.flush()
3436 
 
3437 
  def recv_addSourceItemPricing(self, ):
3438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3439 
    if mtype == TMessageType.EXCEPTION:
3440 
      x = TApplicationException()
3441 
      x.read(self._iprot)
3442 
      self._iprot.readMessageEnd()
3443 
      raise x
3444 
    result = addSourceItemPricing_result()
3445 
    result.read(self._iprot)
3446 
    self._iprot.readMessageEnd()
3447 
    if result.cex is not None:
3448 
      raise result.cex
3449 
    return
3450 
 
3451 
  def getAllSourcePricing(self, itemId):
3452 
    """
3453 
    Returns the list of source pricing information of an item.
3454 
    Raises an exception if item not found corresponding to itemId
3455 
 
3456 
    Parameters:
3457 
     - itemId
3458 
    """
3459 
    self.send_getAllSourcePricing(itemId)
3460 
    return self.recv_getAllSourcePricing()
3461 
 
3462 
  def send_getAllSourcePricing(self, itemId):
3463 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3464 
    args = getAllSourcePricing_args()
3465 
    args.itemId = itemId
3466 
    args.write(self._oprot)
3467 
    self._oprot.writeMessageEnd()
3468 
    self._oprot.trans.flush()
3469 
 
3470 
  def recv_getAllSourcePricing(self, ):
3471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3472 
    if mtype == TMessageType.EXCEPTION:
3473 
      x = TApplicationException()
3474 
      x.read(self._iprot)
3475 
      self._iprot.readMessageEnd()
3476 
      raise x
3477 
    result = getAllSourcePricing_result()
3478 
    result.read(self._iprot)
3479 
    self._iprot.readMessageEnd()
3480 
    if result.success is not None:
3481 
      return result.success
3482 
    if result.cex is not None:
3483 
      raise result.cex
3484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3485 
 
3486 
  def getItemForSource(self, item_id, sourceId):
3487 
    """
3488 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3489 
 
3490 
    Parameters:
3491 
     - item_id
3492 
     - sourceId
3493 
    """
3494 
    self.send_getItemForSource(item_id, sourceId)
3495 
    return self.recv_getItemForSource()
3496 
 
3497 
  def send_getItemForSource(self, item_id, sourceId):
3498 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3499 
    args = getItemForSource_args()
3500 
    args.item_id = item_id
3501 
    args.sourceId = sourceId
3502 
    args.write(self._oprot)
3503 
    self._oprot.writeMessageEnd()
3504 
    self._oprot.trans.flush()
3505 
 
3506 
  def recv_getItemForSource(self, ):
3507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3508 
    if mtype == TMessageType.EXCEPTION:
3509 
      x = TApplicationException()
3510 
      x.read(self._iprot)
3511 
      self._iprot.readMessageEnd()
3512 
      raise x
3513 
    result = getItemForSource_result()
3514 
    result.read(self._iprot)
3515 
    self._iprot.readMessageEnd()
3516 
    if result.success is not None:
3517 
      return result.success
3518 
    if result.cex is not None:
3519 
      raise result.cex
3520 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3521 
 
3522 
  def searchItemsInRange(self, searchTerms, offset, limit):
3523 
    """
3524 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3525 
 
3526 
    Parameters:
3527 
     - searchTerms
3528 
     - offset
3529 
     - limit
3530 
    """
3531 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3532 
    return self.recv_searchItemsInRange()
3533 
 
3534 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3535 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3536 
    args = searchItemsInRange_args()
3537 
    args.searchTerms = searchTerms
3538 
    args.offset = offset
3539 
    args.limit = limit
3540 
    args.write(self._oprot)
3541 
    self._oprot.writeMessageEnd()
3542 
    self._oprot.trans.flush()
3543 
 
3544 
  def recv_searchItemsInRange(self, ):
3545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3546 
    if mtype == TMessageType.EXCEPTION:
3547 
      x = TApplicationException()
3548 
      x.read(self._iprot)
3549 
      self._iprot.readMessageEnd()
3550 
      raise x
3551 
    result = searchItemsInRange_result()
3552 
    result.read(self._iprot)
3553 
    self._iprot.readMessageEnd()
3554 
    if result.success is not None:
3555 
      return result.success
3556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3557 
 
3558 
  def getSearchResultCount(self, searchTerms):
3559 
    """
3560 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3561 
 
3562 
    Parameters:
3563 
     - searchTerms
3564 
    """
3565 
    self.send_getSearchResultCount(searchTerms)
3566 
    return self.recv_getSearchResultCount()
3567 
 
3568 
  def send_getSearchResultCount(self, searchTerms):
3569 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3570 
    args = getSearchResultCount_args()
3571 
    args.searchTerms = searchTerms
3572 
    args.write(self._oprot)
3573 
    self._oprot.writeMessageEnd()
3574 
    self._oprot.trans.flush()
3575 
 
3576 
  def recv_getSearchResultCount(self, ):
3577 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3578 
    if mtype == TMessageType.EXCEPTION:
3579 
      x = TApplicationException()
3580 
      x.read(self._iprot)
3581 
      self._iprot.readMessageEnd()
3582 
      raise x
3583 
    result = getSearchResultCount_result()
3584 
    result.read(self._iprot)
3585 
    self._iprot.readMessageEnd()
3586 
    if result.success is not None:
3587 
      return result.success
3588 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3589 
 
3590 
  def getProductNotifications(self, startDateTime):
3591 
    """
3592 
    Returns a list of product notifications added after a supplied datetime
3593 
 
3594 
    Parameters:
3595 
     - startDateTime
3596 
    """
3597 
    self.send_getProductNotifications(startDateTime)
3598 
    return self.recv_getProductNotifications()
3599 
 
3600 
  def send_getProductNotifications(self, startDateTime):
3601 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3602 
    args = getProductNotifications_args()
3603 
    args.startDateTime = startDateTime
3604 
    args.write(self._oprot)
3605 
    self._oprot.writeMessageEnd()
3606 
    self._oprot.trans.flush()
3607 
 
3608 
  def recv_getProductNotifications(self, ):
3609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3610 
    if mtype == TMessageType.EXCEPTION:
3611 
      x = TApplicationException()
3612 
      x.read(self._iprot)
3613 
      self._iprot.readMessageEnd()
3614 
      raise x
3615 
    result = getProductNotifications_result()
3616 
    result.read(self._iprot)
3617 
    self._iprot.readMessageEnd()
3618 
    if result.success is not None:
3619 
      return result.success
3620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3621 
 
7897 amar.kumar 3622 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3623 
    """
3624 
    Returns a list of count of requests for product notification against each item
3625 
 
3626 
    Parameters:
3627 
     - startDateTime
7897 amar.kumar 3628 
     - categoryId
5944 mandeep.dh 3629 
    """
7897 amar.kumar 3630 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3631 
    return self.recv_getProductNotificationRequestCount()
3632 
 
7897 amar.kumar 3633 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3634 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3635 
    args = getProductNotificationRequestCount_args()
3636 
    args.startDateTime = startDateTime
7897 amar.kumar 3637 
    args.categoryId = categoryId
5944 mandeep.dh 3638 
    args.write(self._oprot)
3639 
    self._oprot.writeMessageEnd()
3640 
    self._oprot.trans.flush()
3641 
 
3642 
  def recv_getProductNotificationRequestCount(self, ):
3643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3644 
    if mtype == TMessageType.EXCEPTION:
3645 
      x = TApplicationException()
3646 
      x.read(self._iprot)
3647 
      self._iprot.readMessageEnd()
3648 
      raise x
3649 
    result = getProductNotificationRequestCount_result()
3650 
    result.read(self._iprot)
3651 
    self._iprot.readMessageEnd()
3652 
    if result.success is not None:
3653 
      return result.success
3654 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3655 
 
3656 
  def addAuthorizationLog(self, itemId, username, reason):
3657 
    """
3658 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3659 
 
3660 
    Parameters:
3661 
     - itemId
3662 
     - username
3663 
     - reason
3664 
    """
3665 
    self.send_addAuthorizationLog(itemId, username, reason)
3666 
    return self.recv_addAuthorizationLog()
3667 
 
3668 
  def send_addAuthorizationLog(self, itemId, username, reason):
3669 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3670 
    args = addAuthorizationLog_args()
3671 
    args.itemId = itemId
3672 
    args.username = username
3673 
    args.reason = reason
3674 
    args.write(self._oprot)
3675 
    self._oprot.writeMessageEnd()
3676 
    self._oprot.trans.flush()
3677 
 
3678 
  def recv_addAuthorizationLog(self, ):
3679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3680 
    if mtype == TMessageType.EXCEPTION:
3681 
      x = TApplicationException()
3682 
      x.read(self._iprot)
3683 
      self._iprot.readMessageEnd()
3684 
      raise x
3685 
    result = addAuthorizationLog_result()
3686 
    result.read(self._iprot)
3687 
    self._iprot.readMessageEnd()
3688 
    if result.success is not None:
3689 
      return result.success
3690 
    if result.cex is not None:
3691 
      raise result.cex
3692 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3693 
 
3694 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3695 
    """
3696 
    Parameters:
3697 
     - catalog_item_id
3698 
     - voucherType
3699 
     - voucherAmount
3700 
    """
3701 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3702 
    return self.recv_addupdateVoucherForItem()
3703 
 
3704 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3705 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3706 
    args = addupdateVoucherForItem_args()
3707 
    args.catalog_item_id = catalog_item_id
3708 
    args.voucherType = voucherType
3709 
    args.voucherAmount = voucherAmount
3710 
    args.write(self._oprot)
3711 
    self._oprot.writeMessageEnd()
3712 
    self._oprot.trans.flush()
3713 
 
3714 
  def recv_addupdateVoucherForItem(self, ):
3715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3716 
    if mtype == TMessageType.EXCEPTION:
3717 
      x = TApplicationException()
3718 
      x.read(self._iprot)
3719 
      self._iprot.readMessageEnd()
3720 
      raise x
3721 
    result = addupdateVoucherForItem_result()
3722 
    result.read(self._iprot)
3723 
    self._iprot.readMessageEnd()
3724 
    if result.success is not None:
3725 
      return result.success
3726 
    if result.cex is not None:
3727 
      raise result.cex
3728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3729 
 
3730 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3731 
    """
3732 
    Parameters:
3733 
     - catalog_item_id
3734 
     - voucherType
3735 
    """
3736 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3737 
    return self.recv_deleteVoucherForItem()
3738 
 
3739 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3740 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3741 
    args = deleteVoucherForItem_args()
3742 
    args.catalog_item_id = catalog_item_id
3743 
    args.voucherType = voucherType
3744 
    args.write(self._oprot)
3745 
    self._oprot.writeMessageEnd()
3746 
    self._oprot.trans.flush()
3747 
 
3748 
  def recv_deleteVoucherForItem(self, ):
3749 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3750 
    if mtype == TMessageType.EXCEPTION:
3751 
      x = TApplicationException()
3752 
      x.read(self._iprot)
3753 
      self._iprot.readMessageEnd()
3754 
      raise x
3755 
    result = deleteVoucherForItem_result()
3756 
    result.read(self._iprot)
3757 
    self._iprot.readMessageEnd()
3758 
    if result.success is not None:
3759 
      return result.success
3760 
    if result.cex is not None:
3761 
      raise result.cex
3762 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3763 
 
3764 
  def getVoucherAmount(self, itemId, voucherType):
3765 
    """
3766 
    Parameters:
3767 
     - itemId
3768 
     - voucherType
3769 
    """
3770 
    self.send_getVoucherAmount(itemId, voucherType)
3771 
    return self.recv_getVoucherAmount()
3772 
 
3773 
  def send_getVoucherAmount(self, itemId, voucherType):
3774 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3775 
    args = getVoucherAmount_args()
3776 
    args.itemId = itemId
3777 
    args.voucherType = voucherType
3778 
    args.write(self._oprot)
3779 
    self._oprot.writeMessageEnd()
3780 
    self._oprot.trans.flush()
3781 
 
3782 
  def recv_getVoucherAmount(self, ):
3783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3784 
    if mtype == TMessageType.EXCEPTION:
3785 
      x = TApplicationException()
3786 
      x.read(self._iprot)
3787 
      self._iprot.readMessageEnd()
3788 
      raise x
3789 
    result = getVoucherAmount_result()
3790 
    result.read(self._iprot)
3791 
    self._iprot.readMessageEnd()
3792 
    if result.success is not None:
3793 
      return result.success
3794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3795 
 
3796 
  def getAllItemVouchers(self, itemId):
3797 
    """
3798 
    Parameters:
3799 
     - itemId
3800 
    """
3801 
    self.send_getAllItemVouchers(itemId)
3802 
    return self.recv_getAllItemVouchers()
3803 
 
3804 
  def send_getAllItemVouchers(self, itemId):
3805 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3806 
    args = getAllItemVouchers_args()
3807 
    args.itemId = itemId
3808 
    args.write(self._oprot)
3809 
    self._oprot.writeMessageEnd()
3810 
    self._oprot.trans.flush()
3811 
 
3812 
  def recv_getAllItemVouchers(self, ):
3813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3814 
    if mtype == TMessageType.EXCEPTION:
3815 
      x = TApplicationException()
3816 
      x.read(self._iprot)
3817 
      self._iprot.readMessageEnd()
3818 
      raise x
3819 
    result = getAllItemVouchers_result()
3820 
    result.read(self._iprot)
3821 
    self._iprot.readMessageEnd()
3822 
    if result.success is not None:
3823 
      return result.success
3824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3825 
 
3826 
  def isValidCatalogItemId(self, catalog_item_id):
3827 
    """
3828 
    Parameters:
3829 
     - catalog_item_id
3830 
    """
3831 
    self.send_isValidCatalogItemId(catalog_item_id)
3832 
    return self.recv_isValidCatalogItemId()
3833 
 
3834 
  def send_isValidCatalogItemId(self, catalog_item_id):
3835 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3836 
    args = isValidCatalogItemId_args()
3837 
    args.catalog_item_id = catalog_item_id
3838 
    args.write(self._oprot)
3839 
    self._oprot.writeMessageEnd()
3840 
    self._oprot.trans.flush()
3841 
 
3842 
  def recv_isValidCatalogItemId(self, ):
3843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3844 
    if mtype == TMessageType.EXCEPTION:
3845 
      x = TApplicationException()
3846 
      x.read(self._iprot)
3847 
      self._iprot.readMessageEnd()
3848 
      raise x
3849 
    result = isValidCatalogItemId_result()
3850 
    result.read(self._iprot)
3851 
    self._iprot.readMessageEnd()
3852 
    if result.success is not None:
3853 
      return result.success
3854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3855 
 
7330 amit.gupta 3856 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3857 
    """
3858 
    Parameters:
3859 
     - itemId
7330 amit.gupta 3860 
     - stateId
6039 amit.gupta 3861 
     - price
3862 
    """
7330 amit.gupta 3863 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3864 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3865 
 
7330 amit.gupta 3866 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3867 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3868 
    args = getVatPercentageForItem_args()
3869 
    args.itemId = itemId
7330 amit.gupta 3870 
    args.stateId = stateId
6039 amit.gupta 3871 
    args.price = price
3872 
    args.write(self._oprot)
3873 
    self._oprot.writeMessageEnd()
3874 
    self._oprot.trans.flush()
3875 
 
3876 
  def recv_getVatPercentageForItem(self, ):
3877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3878 
    if mtype == TMessageType.EXCEPTION:
3879 
      x = TApplicationException()
3880 
      x.read(self._iprot)
3881 
      self._iprot.readMessageEnd()
3882 
      raise x
3883 
    result = getVatPercentageForItem_result()
3884 
    result.read(self._iprot)
3885 
    self._iprot.readMessageEnd()
3886 
    if result.success is not None:
3887 
      return result.success
7340 amit.gupta 3888 
    if result.cex is not None:
3889 
      raise result.cex
6039 amit.gupta 3890 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3891 
 
3892 
  def getVatAmountForItem(self, itemId, price):
3893 
    """
3894 
    Parameters:
3895 
     - itemId
3896 
     - price
3897 
    """
3898 
    self.send_getVatAmountForItem(itemId, price)
3899 
    return self.recv_getVatAmountForItem()
3900 
 
3901 
  def send_getVatAmountForItem(self, itemId, price):
3902 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3903 
    args = getVatAmountForItem_args()
3904 
    args.itemId = itemId
3905 
    args.price = price
3906 
    args.write(self._oprot)
3907 
    self._oprot.writeMessageEnd()
3908 
    self._oprot.trans.flush()
3909 
 
3910 
  def recv_getVatAmountForItem(self, ):
3911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3912 
    if mtype == TMessageType.EXCEPTION:
3913 
      x = TApplicationException()
3914 
      x.read(self._iprot)
3915 
      self._iprot.readMessageEnd()
3916 
      raise x
3917 
    result = getVatAmountForItem_result()
3918 
    result.read(self._iprot)
3919 
    self._iprot.readMessageEnd()
3920 
    if result.success is not None:
3921 
      return result.success
3922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3923 
 
6531 vikram.rag 3924 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3925 
    """
3926 
    Parameters:
3927 
     - offset
3928 
     - limit
3929 
    """
3930 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3931 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3932 
 
6531 vikram.rag 3933 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3934 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3935 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3936 
    args.offset = offset
3937 
    args.limit = limit
3938 
    args.write(self._oprot)
3939 
    self._oprot.writeMessageEnd()
3940 
    self._oprot.trans.flush()
3941 
 
3942 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3944 
    if mtype == TMessageType.EXCEPTION:
3945 
      x = TApplicationException()
3946 
      x.read(self._iprot)
3947 
      self._iprot.readMessageEnd()
3948 
      raise x
3949 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3950 
    result.read(self._iprot)
3951 
    self._iprot.readMessageEnd()
3952 
    if result.success is not None:
3953 
      return result.success
3954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3955 
 
6821 amar.kumar 3956 
  def getAllAliveItems(self, ):
3957 
    self.send_getAllAliveItems()
3958 
    return self.recv_getAllAliveItems()
3959 
 
3960 
  def send_getAllAliveItems(self, ):
3961 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3962 
    args = getAllAliveItems_args()
3963 
    args.write(self._oprot)
3964 
    self._oprot.writeMessageEnd()
3965 
    self._oprot.trans.flush()
3966 
 
3967 
  def recv_getAllAliveItems(self, ):
3968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3969 
    if mtype == TMessageType.EXCEPTION:
3970 
      x = TApplicationException()
3971 
      x.read(self._iprot)
3972 
      self._iprot.readMessageEnd()
3973 
      raise x
3974 
    result = getAllAliveItems_result()
3975 
    result.read(self._iprot)
3976 
    self._iprot.readMessageEnd()
3977 
    if result.success is not None:
3978 
      return result.success
3979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3980 
 
6921 anupam.sin 3981 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3982 
    """
3983 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3984 
 
6805 anupam.sin 3985 
    Parameters:
3986 
     - itemId
6921 anupam.sin 3987 
     - price
6805 anupam.sin 3988 
     - insurerId
3989 
     - quantity
3990 
    """
6921 anupam.sin 3991 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3992 
    return self.recv_getInsuranceAmount()
3993 
 
6921 anupam.sin 3994 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3995 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3996 
    args = getInsuranceAmount_args()
3997 
    args.itemId = itemId
6921 anupam.sin 3998 
    args.price = price
6805 anupam.sin 3999 
    args.insurerId = insurerId
4000 
    args.quantity = quantity
4001 
    args.write(self._oprot)
4002 
    self._oprot.writeMessageEnd()
4003 
    self._oprot.trans.flush()
4004 
 
4005 
  def recv_getInsuranceAmount(self, ):
4006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4007 
    if mtype == TMessageType.EXCEPTION:
4008 
      x = TApplicationException()
4009 
      x.read(self._iprot)
4010 
      self._iprot.readMessageEnd()
4011 
      raise x
4012 
    result = getInsuranceAmount_result()
4013 
    result.read(self._iprot)
4014 
    self._iprot.readMessageEnd()
4015 
    if result.success is not None:
4016 
      return result.success
4017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
4018 
 
4019 
  def getInsurer(self, insurerId):
4020 
    """
4021 
    Parameters:
4022 
     - insurerId
4023 
    """
4024 
    self.send_getInsurer(insurerId)
4025 
    return self.recv_getInsurer()
4026 
 
4027 
  def send_getInsurer(self, insurerId):
4028 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
4029 
    args = getInsurer_args()
4030 
    args.insurerId = insurerId
4031 
    args.write(self._oprot)
4032 
    self._oprot.writeMessageEnd()
4033 
    self._oprot.trans.flush()
4034 
 
4035 
  def recv_getInsurer(self, ):
4036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4037 
    if mtype == TMessageType.EXCEPTION:
4038 
      x = TApplicationException()
4039 
      x.read(self._iprot)
4040 
      self._iprot.readMessageEnd()
4041 
      raise x
4042 
    result = getInsurer_result()
4043 
    result.read(self._iprot)
4044 
    self._iprot.readMessageEnd()
4045 
    if result.success is not None:
4046 
      return result.success
4047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
4048 
 
6838 vikram.rag 4049 
  def getAllInsurers(self, ):
4050 
    self.send_getAllInsurers()
4051 
    return self.recv_getAllInsurers()
6805 anupam.sin 4052 
 
6838 vikram.rag 4053 
  def send_getAllInsurers(self, ):
4054 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
4055 
    args = getAllInsurers_args()
4056 
    args.write(self._oprot)
4057 
    self._oprot.writeMessageEnd()
4058 
    self._oprot.trans.flush()
4059 
 
4060 
  def recv_getAllInsurers(self, ):
4061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4062 
    if mtype == TMessageType.EXCEPTION:
4063 
      x = TApplicationException()
4064 
      x.read(self._iprot)
4065 
      self._iprot.readMessageEnd()
4066 
      raise x
4067 
    result = getAllInsurers_result()
4068 
    result.read(self._iprot)
4069 
    self._iprot.readMessageEnd()
4070 
    if result.success is not None:
4071 
      return result.success
4072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
4073 
 
6962 rajveer 4074 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
4075 
    """
4076 
    Parameters:
4077 
     - insurerId
4078 
     - amount
4079 
    """
4080 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
4081 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 4082 
 
6962 rajveer 4083 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
4084 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
4085 
    args = updateInsuranceDeclaredAmount_args()
4086 
    args.insurerId = insurerId
4087 
    args.amount = amount
4088 
    args.write(self._oprot)
4089 
    self._oprot.writeMessageEnd()
4090 
    self._oprot.trans.flush()
4091 
 
4092 
  def recv_updateInsuranceDeclaredAmount(self, ):
4093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4094 
    if mtype == TMessageType.EXCEPTION:
4095 
      x = TApplicationException()
4096 
      x.read(self._iprot)
4097 
      self._iprot.readMessageEnd()
4098 
      raise x
4099 
    result = updateInsuranceDeclaredAmount_result()
4100 
    result.read(self._iprot)
4101 
    self._iprot.readMessageEnd()
4102 
    return
4103 
 
7190 amar.kumar 4104 
  def getFreebieForItem(self, itemId):
4105 
    """
4106 
    Parameters:
4107 
     - itemId
4108 
    """
4109 
    self.send_getFreebieForItem(itemId)
4110 
    return self.recv_getFreebieForItem()
6962 rajveer 4111 
 
7190 amar.kumar 4112 
  def send_getFreebieForItem(self, itemId):
4113 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
4114 
    args = getFreebieForItem_args()
4115 
    args.itemId = itemId
4116 
    args.write(self._oprot)
4117 
    self._oprot.writeMessageEnd()
4118 
    self._oprot.trans.flush()
4119 
 
4120 
  def recv_getFreebieForItem(self, ):
4121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4122 
    if mtype == TMessageType.EXCEPTION:
4123 
      x = TApplicationException()
4124 
      x.read(self._iprot)
4125 
      self._iprot.readMessageEnd()
4126 
      raise x
4127 
    result = getFreebieForItem_result()
4128 
    result.read(self._iprot)
4129 
    self._iprot.readMessageEnd()
4130 
    if result.success is not None:
4131 
      return result.success
4132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
4133 
 
4134 
  def addOrUpdateFreebieForItem(self, freebieItem):
4135 
    """
4136 
    Parameters:
4137 
     - freebieItem
4138 
    """
4139 
    self.send_addOrUpdateFreebieForItem(freebieItem)
4140 
    self.recv_addOrUpdateFreebieForItem()
4141 
 
4142 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
4143 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
4144 
    args = addOrUpdateFreebieForItem_args()
4145 
    args.freebieItem = freebieItem
4146 
    args.write(self._oprot)
4147 
    self._oprot.writeMessageEnd()
4148 
    self._oprot.trans.flush()
4149 
 
4150 
  def recv_addOrUpdateFreebieForItem(self, ):
4151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4152 
    if mtype == TMessageType.EXCEPTION:
4153 
      x = TApplicationException()
4154 
      x.read(self._iprot)
4155 
      self._iprot.readMessageEnd()
4156 
      raise x
4157 
    result = addOrUpdateFreebieForItem_result()
4158 
    result.read(self._iprot)
4159 
    self._iprot.readMessageEnd()
4160 
    return
4161 
 
7272 amit.gupta 4162 
  def addOrUpdateBrandInfo(self, brandInfo):
4163 
    """
4164 
    Parameters:
4165 
     - brandInfo
4166 
    """
4167 
    self.send_addOrUpdateBrandInfo(brandInfo)
4168 
    self.recv_addOrUpdateBrandInfo()
4169 
 
4170 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4171 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4172 
    args = addOrUpdateBrandInfo_args()
4173 
    args.brandInfo = brandInfo
4174 
    args.write(self._oprot)
4175 
    self._oprot.writeMessageEnd()
4176 
    self._oprot.trans.flush()
4177 
 
4178 
  def recv_addOrUpdateBrandInfo(self, ):
4179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4180 
    if mtype == TMessageType.EXCEPTION:
4181 
      x = TApplicationException()
4182 
      x.read(self._iprot)
4183 
      self._iprot.readMessageEnd()
4184 
      raise x
4185 
    result = addOrUpdateBrandInfo_result()
4186 
    result.read(self._iprot)
4187 
    self._iprot.readMessageEnd()
4188 
    return
4189 
 
4190 
  def getBrandInfo(self, ):
4191 
    self.send_getBrandInfo()
4192 
    return self.recv_getBrandInfo()
4193 
 
4194 
  def send_getBrandInfo(self, ):
4195 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4196 
    args = getBrandInfo_args()
4197 
    args.write(self._oprot)
4198 
    self._oprot.writeMessageEnd()
4199 
    self._oprot.trans.flush()
4200 
 
4201 
  def recv_getBrandInfo(self, ):
4202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4203 
    if mtype == TMessageType.EXCEPTION:
4204 
      x = TApplicationException()
4205 
      x.read(self._iprot)
4206 
      self._iprot.readMessageEnd()
4207 
      raise x
4208 
    result = getBrandInfo_result()
4209 
    result.read(self._iprot)
4210 
    self._iprot.readMessageEnd()
4211 
    if result.success is not None:
4212 
      return result.success
4213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4214 
 
7256 rajveer 4215 
  def getStorePricing(self, itemId):
4216 
    """
4217 
    Parameters:
4218 
     - itemId
4219 
    """
4220 
    self.send_getStorePricing(itemId)
4221 
    return self.recv_getStorePricing()
7190 amar.kumar 4222 
 
7256 rajveer 4223 
  def send_getStorePricing(self, itemId):
4224 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4225 
    args = getStorePricing_args()
4226 
    args.itemId = itemId
4227 
    args.write(self._oprot)
4228 
    self._oprot.writeMessageEnd()
4229 
    self._oprot.trans.flush()
4230 
 
4231 
  def recv_getStorePricing(self, ):
4232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4233 
    if mtype == TMessageType.EXCEPTION:
4234 
      x = TApplicationException()
4235 
      x.read(self._iprot)
4236 
      self._iprot.readMessageEnd()
4237 
      raise x
4238 
    result = getStorePricing_result()
4239 
    result.read(self._iprot)
4240 
    self._iprot.readMessageEnd()
4241 
    if result.success is not None:
4242 
      return result.success
4243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4244 
 
7306 rajveer 4245 
  def getStorePricings(self, itemIds):
4246 
    """
4247 
    Parameters:
4248 
     - itemIds
4249 
    """
4250 
    self.send_getStorePricings(itemIds)
4251 
    return self.recv_getStorePricings()
4252 
 
4253 
  def send_getStorePricings(self, itemIds):
4254 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4255 
    args = getStorePricings_args()
4256 
    args.itemIds = itemIds
4257 
    args.write(self._oprot)
4258 
    self._oprot.writeMessageEnd()
4259 
    self._oprot.trans.flush()
4260 
 
4261 
  def recv_getStorePricings(self, ):
4262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4263 
    if mtype == TMessageType.EXCEPTION:
4264 
      x = TApplicationException()
4265 
      x.read(self._iprot)
4266 
      self._iprot.readMessageEnd()
4267 
      raise x
4268 
    result = getStorePricings_result()
4269 
    result.read(self._iprot)
4270 
    self._iprot.readMessageEnd()
4271 
    if result.success is not None:
4272 
      return result.success
4273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4274 
 
7382 rajveer 4275 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4276 
    """
4277 
    Parameters:
4278 
     - sp
7382 rajveer 4279 
     - allColors
7265 rajveer 4280 
    """
7382 rajveer 4281 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4282 
    self.recv_updateStorePricing()
7256 rajveer 4283 
 
7382 rajveer 4284 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4285 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4286 
    args = updateStorePricing_args()
4287 
    args.sp = sp
7382 rajveer 4288 
    args.allColors = allColors
7265 rajveer 4289 
    args.write(self._oprot)
4290 
    self._oprot.writeMessageEnd()
4291 
    self._oprot.trans.flush()
4292 
 
4293 
  def recv_updateStorePricing(self, ):
4294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4295 
    if mtype == TMessageType.EXCEPTION:
4296 
      x = TApplicationException()
4297 
      x.read(self._iprot)
4298 
      self._iprot.readMessageEnd()
4299 
      raise x
4300 
    result = updateStorePricing_result()
4301 
    result.read(self._iprot)
4302 
    self._iprot.readMessageEnd()
4303 
    return
4304 
 
7281 kshitij.so 4305 
  def getAllAmazonListedItems(self, ):
4306 
    self.send_getAllAmazonListedItems()
4307 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4308 
 
7281 kshitij.so 4309 
  def send_getAllAmazonListedItems(self, ):
4310 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4311 
    args = getAllAmazonListedItems_args()
4312 
    args.write(self._oprot)
4313 
    self._oprot.writeMessageEnd()
4314 
    self._oprot.trans.flush()
4315 
 
4316 
  def recv_getAllAmazonListedItems(self, ):
4317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4318 
    if mtype == TMessageType.EXCEPTION:
4319 
      x = TApplicationException()
4320 
      x.read(self._iprot)
4321 
      self._iprot.readMessageEnd()
4322 
      raise x
4323 
    result = getAllAmazonListedItems_result()
4324 
    result.read(self._iprot)
4325 
    self._iprot.readMessageEnd()
4326 
    if result.success is not None:
4327 
      return result.success
4328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4329 
 
8619 kshitij.so 4330 
  def searchAmazonItems(self, searchTerm, offset, limit):
4331 
    """
4332 
    Parameters:
4333 
     - searchTerm
4334 
     - offset
4335 
     - limit
4336 
    """
4337 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4338 
    return self.recv_searchAmazonItems()
4339 
 
4340 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4341 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4342 
    args = searchAmazonItems_args()
4343 
    args.searchTerm = searchTerm
4344 
    args.offset = offset
4345 
    args.limit = limit
4346 
    args.write(self._oprot)
4347 
    self._oprot.writeMessageEnd()
4348 
    self._oprot.trans.flush()
4349 
 
4350 
  def recv_searchAmazonItems(self, ):
4351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4352 
    if mtype == TMessageType.EXCEPTION:
4353 
      x = TApplicationException()
4354 
      x.read(self._iprot)
4355 
      self._iprot.readMessageEnd()
4356 
      raise x
4357 
    result = searchAmazonItems_result()
4358 
    result.read(self._iprot)
4359 
    self._iprot.readMessageEnd()
4360 
    if result.success is not None:
4361 
      return result.success
4362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4363 
 
4364 
  def getAmazonSearchResultCount(self, searchTerm):
4365 
    """
4366 
    Parameters:
4367 
     - searchTerm
4368 
    """
4369 
    self.send_getAmazonSearchResultCount(searchTerm)
4370 
    return self.recv_getAmazonSearchResultCount()
4371 
 
4372 
  def send_getAmazonSearchResultCount(self, searchTerm):
4373 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4374 
    args = getAmazonSearchResultCount_args()
4375 
    args.searchTerm = searchTerm
4376 
    args.write(self._oprot)
4377 
    self._oprot.writeMessageEnd()
4378 
    self._oprot.trans.flush()
4379 
 
4380 
  def recv_getAmazonSearchResultCount(self, ):
4381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4382 
    if mtype == TMessageType.EXCEPTION:
4383 
      x = TApplicationException()
4384 
      x.read(self._iprot)
4385 
      self._iprot.readMessageEnd()
4386 
      raise x
4387 
    result = getAmazonSearchResultCount_result()
4388 
    result.read(self._iprot)
4389 
    self._iprot.readMessageEnd()
4390 
    if result.success is not None:
4391 
      return result.success
4392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4393 
 
4394 
  def getCountForAmazonlistedItems(self, ):
4395 
    self.send_getCountForAmazonlistedItems()
4396 
    return self.recv_getCountForAmazonlistedItems()
4397 
 
4398 
  def send_getCountForAmazonlistedItems(self, ):
4399 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4400 
    args = getCountForAmazonlistedItems_args()
4401 
    args.write(self._oprot)
4402 
    self._oprot.writeMessageEnd()
4403 
    self._oprot.trans.flush()
4404 
 
4405 
  def recv_getCountForAmazonlistedItems(self, ):
4406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4407 
    if mtype == TMessageType.EXCEPTION:
4408 
      x = TApplicationException()
4409 
      x.read(self._iprot)
4410 
      self._iprot.readMessageEnd()
4411 
      raise x
4412 
    result = getCountForAmazonlistedItems_result()
4413 
    result.read(self._iprot)
4414 
    self._iprot.readMessageEnd()
4415 
    if result.success is not None:
4416 
      return result.success
4417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4418 
 
7281 kshitij.so 4419 
  def getAmazonItemDetails(self, itemId):
4420 
    """
4421 
    Parameters:
4422 
     - itemId
4423 
    """
4424 
    self.send_getAmazonItemDetails(itemId)
4425 
    return self.recv_getAmazonItemDetails()
4426 
 
4427 
  def send_getAmazonItemDetails(self, itemId):
4428 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4429 
    args = getAmazonItemDetails_args()
4430 
    args.itemId = itemId
4431 
    args.write(self._oprot)
4432 
    self._oprot.writeMessageEnd()
4433 
    self._oprot.trans.flush()
4434 
 
4435 
  def recv_getAmazonItemDetails(self, ):
4436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4437 
    if mtype == TMessageType.EXCEPTION:
4438 
      x = TApplicationException()
4439 
      x.read(self._iprot)
4440 
      self._iprot.readMessageEnd()
4441 
      raise x
4442 
    result = getAmazonItemDetails_result()
4443 
    result.read(self._iprot)
4444 
    self._iprot.readMessageEnd()
4445 
    if result.success is not None:
4446 
      return result.success
4447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4448 
 
8168 kshitij.so 4449 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4450 
    """
4451 
    Parameters:
8168 kshitij.so 4452 
     - amazonlisted
7281 kshitij.so 4453 
    """
8168 kshitij.so 4454 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4455 
    self.recv_updateAmazonItemDetails()
4456 
 
8168 kshitij.so 4457 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4458 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4459 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4460 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4461 
    args.write(self._oprot)
4462 
    self._oprot.writeMessageEnd()
4463 
    self._oprot.trans.flush()
4464 
 
4465 
  def recv_updateAmazonItemDetails(self, ):
4466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4467 
    if mtype == TMessageType.EXCEPTION:
4468 
      x = TApplicationException()
4469 
      x.read(self._iprot)
4470 
      self._iprot.readMessageEnd()
4471 
      raise x
4472 
    result = updateAmazonItemDetails_result()
4473 
    result.read(self._iprot)
4474 
    self._iprot.readMessageEnd()
4475 
    return
4476 
 
4477 
  def addAmazonItem(self, amazonlisted):
4478 
    """
4479 
    Parameters:
4480 
     - amazonlisted
4481 
    """
4482 
    self.send_addAmazonItem(amazonlisted)
4483 
    self.recv_addAmazonItem()
4484 
 
4485 
  def send_addAmazonItem(self, amazonlisted):
4486 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4487 
    args = addAmazonItem_args()
4488 
    args.amazonlisted = amazonlisted
4489 
    args.write(self._oprot)
4490 
    self._oprot.writeMessageEnd()
4491 
    self._oprot.trans.flush()
4492 
 
4493 
  def recv_addAmazonItem(self, ):
4494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4495 
    if mtype == TMessageType.EXCEPTION:
4496 
      x = TApplicationException()
4497 
      x.read(self._iprot)
4498 
      self._iprot.readMessageEnd()
4499 
      raise x
4500 
    result = addAmazonItem_result()
4501 
    result.read(self._iprot)
4502 
    self._iprot.readMessageEnd()
4503 
    return
4504 
 
7291 vikram.rag 4505 
  def getAsinItems(self, ):
4506 
    self.send_getAsinItems()
4507 
    return self.recv_getAsinItems()
7281 kshitij.so 4508 
 
7291 vikram.rag 4509 
  def send_getAsinItems(self, ):
4510 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4511 
    args = getAsinItems_args()
4512 
    args.write(self._oprot)
4513 
    self._oprot.writeMessageEnd()
4514 
    self._oprot.trans.flush()
4515 
 
4516 
  def recv_getAsinItems(self, ):
4517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4518 
    if mtype == TMessageType.EXCEPTION:
4519 
      x = TApplicationException()
4520 
      x.read(self._iprot)
4521 
      self._iprot.readMessageEnd()
4522 
      raise x
4523 
    result = getAsinItems_result()
4524 
    result.read(self._iprot)
4525 
    self._iprot.readMessageEnd()
4526 
    if result.success is not None:
4527 
      return result.success
4528 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4529 
 
4530 
  def getAllFbaListedItems(self, ):
4531 
    self.send_getAllFbaListedItems()
4532 
    return self.recv_getAllFbaListedItems()
4533 
 
4534 
  def send_getAllFbaListedItems(self, ):
4535 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4536 
    args = getAllFbaListedItems_args()
4537 
    args.write(self._oprot)
4538 
    self._oprot.writeMessageEnd()
4539 
    self._oprot.trans.flush()
4540 
 
4541 
  def recv_getAllFbaListedItems(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 = getAllFbaListedItems_result()
4549 
    result.read(self._iprot)
4550 
    self._iprot.readMessageEnd()
4551 
    if result.success is not None:
4552 
      return result.success
4553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4554 
 
4555 
  def getAllNonFbaListedItems(self, ):
4556 
    self.send_getAllNonFbaListedItems()
4557 
    return self.recv_getAllNonFbaListedItems()
4558 
 
4559 
  def send_getAllNonFbaListedItems(self, ):
4560 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4561 
    args = getAllNonFbaListedItems_args()
4562 
    args.write(self._oprot)
4563 
    self._oprot.writeMessageEnd()
4564 
    self._oprot.trans.flush()
4565 
 
4566 
  def recv_getAllNonFbaListedItems(self, ):
4567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4568 
    if mtype == TMessageType.EXCEPTION:
4569 
      x = TApplicationException()
4570 
      x.read(self._iprot)
4571 
      self._iprot.readMessageEnd()
4572 
      raise x
4573 
    result = getAllNonFbaListedItems_result()
4574 
    result.read(self._iprot)
4575 
    self._iprot.readMessageEnd()
4576 
    if result.success is not None:
4577 
      return result.success
4578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4579 
 
7460 kshitij.so 4580 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4581 
    """
4582 
    Parameters:
4583 
     - itemId
4584 
     - holdInventory
4585 
     - defaultInventory
4586 
    """
4587 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4588 
    return self.recv_updateItemInventory()
7291 vikram.rag 4589 
 
7460 kshitij.so 4590 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4591 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4592 
    args = updateItemInventory_args()
4593 
    args.itemId = itemId
4594 
    args.holdInventory = holdInventory
4595 
    args.defaultInventory = defaultInventory
4596 
    args.write(self._oprot)
4597 
    self._oprot.writeMessageEnd()
4598 
    self._oprot.trans.flush()
4599 
 
4600 
  def recv_updateItemInventory(self, ):
4601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4602 
    if mtype == TMessageType.EXCEPTION:
4603 
      x = TApplicationException()
4604 
      x.read(self._iprot)
4605 
      self._iprot.readMessageEnd()
4606 
      raise x
4607 
    result = updateItemInventory_result()
4608 
    result.read(self._iprot)
4609 
    self._iprot.readMessageEnd()
4610 
    if result.success is not None:
4611 
      return result.success
4612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4613 
 
7770 kshitij.so 4614 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4615 
    """
4616 
    Parameters:
4617 
     - type
4618 
     - sku
4619 
     - timestamp
4620 
    """
4621 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4622 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4623 
 
7770 kshitij.so 4624 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4625 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4626 
    args = updateTimestampForAmazonFeeds_args()
4627 
    args.type = type
4628 
    args.sku = sku
4629 
    args.timestamp = timestamp
4630 
    args.write(self._oprot)
4631 
    self._oprot.writeMessageEnd()
4632 
    self._oprot.trans.flush()
4633 
 
4634 
  def recv_updateTimestampForAmazonFeeds(self, ):
4635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4636 
    if mtype == TMessageType.EXCEPTION:
4637 
      x = TApplicationException()
4638 
      x.read(self._iprot)
4639 
      self._iprot.readMessageEnd()
4640 
      raise x
4641 
    result = updateTimestampForAmazonFeeds_result()
4642 
    result.read(self._iprot)
4643 
    self._iprot.readMessageEnd()
4644 
    if result.success is not None:
4645 
      return result.success
4646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4647 
 
7897 amar.kumar 4648 
  def getAllParentCategories(self, ):
4649 
    self.send_getAllParentCategories()
4650 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4651 
 
7897 amar.kumar 4652 
  def send_getAllParentCategories(self, ):
4653 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4654 
    args = getAllParentCategories_args()
4655 
    args.write(self._oprot)
4656 
    self._oprot.writeMessageEnd()
4657 
    self._oprot.trans.flush()
4658 
 
4659 
  def recv_getAllParentCategories(self, ):
4660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4661 
    if mtype == TMessageType.EXCEPTION:
4662 
      x = TApplicationException()
4663 
      x.read(self._iprot)
4664 
      self._iprot.readMessageEnd()
4665 
      raise x
4666 
    result = getAllParentCategories_result()
4667 
    result.read(self._iprot)
4668 
    self._iprot.readMessageEnd()
4669 
    if result.success is not None:
4670 
      return result.success
4671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4672 
 
7977 kshitij.so 4673 
  def addPageViewEvent(self, pageViewEvents):
4674 
    """
4675 
    Parameters:
4676 
     - pageViewEvents
4677 
    """
4678 
    self.send_addPageViewEvent(pageViewEvents)
4679 
    self.recv_addPageViewEvent()
7897 amar.kumar 4680 
 
7977 kshitij.so 4681 
  def send_addPageViewEvent(self, pageViewEvents):
4682 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4683 
    args = addPageViewEvent_args()
4684 
    args.pageViewEvents = pageViewEvents
4685 
    args.write(self._oprot)
4686 
    self._oprot.writeMessageEnd()
4687 
    self._oprot.trans.flush()
4688 
 
4689 
  def recv_addPageViewEvent(self, ):
4690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4691 
    if mtype == TMessageType.EXCEPTION:
4692 
      x = TApplicationException()
4693 
      x.read(self._iprot)
4694 
      self._iprot.readMessageEnd()
4695 
      raise x
4696 
    result = addPageViewEvent_result()
4697 
    result.read(self._iprot)
4698 
    self._iprot.readMessageEnd()
4699 
    return
4700 
 
4701 
  def addCartEvent(self, cartEvents):
4702 
    """
4703 
    Parameters:
4704 
     - cartEvents
4705 
    """
4706 
    self.send_addCartEvent(cartEvents)
4707 
    self.recv_addCartEvent()
4708 
 
4709 
  def send_addCartEvent(self, cartEvents):
4710 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4711 
    args = addCartEvent_args()
4712 
    args.cartEvents = cartEvents
4713 
    args.write(self._oprot)
4714 
    self._oprot.writeMessageEnd()
4715 
    self._oprot.trans.flush()
4716 
 
4717 
  def recv_addCartEvent(self, ):
4718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4719 
    if mtype == TMessageType.EXCEPTION:
4720 
      x = TApplicationException()
4721 
      x.read(self._iprot)
4722 
      self._iprot.readMessageEnd()
4723 
      raise x
4724 
    result = addCartEvent_result()
4725 
    result.read(self._iprot)
4726 
    self._iprot.readMessageEnd()
4727 
    return
4728 
 
8182 amar.kumar 4729 
  def addEbayItem(self, ebayItem):
4730 
    """
4731 
    Parameters:
4732 
     - ebayItem
4733 
    """
4734 
    self.send_addEbayItem(ebayItem)
4735 
    self.recv_addEbayItem()
4736 
 
4737 
  def send_addEbayItem(self, ebayItem):
4738 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4739 
    args = addEbayItem_args()
4740 
    args.ebayItem = ebayItem
4741 
    args.write(self._oprot)
4742 
    self._oprot.writeMessageEnd()
4743 
    self._oprot.trans.flush()
4744 
 
4745 
  def recv_addEbayItem(self, ):
4746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4747 
    if mtype == TMessageType.EXCEPTION:
4748 
      x = TApplicationException()
4749 
      x.read(self._iprot)
4750 
      self._iprot.readMessageEnd()
4751 
      raise x
4752 
    result = addEbayItem_result()
4753 
    result.read(self._iprot)
4754 
    self._iprot.readMessageEnd()
4755 
    return
4756 
 
4757 
  def getEbayItem(self, listingId):
4758 
    """
4759 
    Parameters:
4760 
     - listingId
4761 
    """
4762 
    self.send_getEbayItem(listingId)
4763 
    return self.recv_getEbayItem()
4764 
 
4765 
  def send_getEbayItem(self, listingId):
4766 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4767 
    args = getEbayItem_args()
4768 
    args.listingId = listingId
4769 
    args.write(self._oprot)
4770 
    self._oprot.writeMessageEnd()
4771 
    self._oprot.trans.flush()
4772 
 
4773 
  def recv_getEbayItem(self, ):
4774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4775 
    if mtype == TMessageType.EXCEPTION:
4776 
      x = TApplicationException()
4777 
      x.read(self._iprot)
4778 
      self._iprot.readMessageEnd()
4779 
      raise x
4780 
    result = getEbayItem_result()
4781 
    result.read(self._iprot)
4782 
    self._iprot.readMessageEnd()
4783 
    if result.success is not None:
4784 
      return result.success
4785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4786 
 
4787 
  def updateEbayItem(self, ebayItem):
4788 
    """
4789 
    Parameters:
4790 
     - ebayItem
4791 
    """
4792 
    self.send_updateEbayItem(ebayItem)
4793 
    self.recv_updateEbayItem()
4794 
 
4795 
  def send_updateEbayItem(self, ebayItem):
4796 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4797 
    args = updateEbayItem_args()
4798 
    args.ebayItem = ebayItem
4799 
    args.write(self._oprot)
4800 
    self._oprot.writeMessageEnd()
4801 
    self._oprot.trans.flush()
4802 
 
4803 
  def recv_updateEbayItem(self, ):
4804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4805 
    if mtype == TMessageType.EXCEPTION:
4806 
      x = TApplicationException()
4807 
      x.read(self._iprot)
4808 
      self._iprot.readMessageEnd()
4809 
      raise x
4810 
    result = updateEbayItem_result()
4811 
    result.read(self._iprot)
4812 
    self._iprot.readMessageEnd()
4813 
    return
4814 
 
8139 kshitij.so 4815 
  def getAmazonListedItems(self, offset, limit):
4816 
    """
4817 
    Parameters:
4818 
     - offset
4819 
     - limit
4820 
    """
4821 
    self.send_getAmazonListedItems(offset, limit)
4822 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4823 
 
8139 kshitij.so 4824 
  def send_getAmazonListedItems(self, offset, limit):
4825 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4826 
    args = getAmazonListedItems_args()
4827 
    args.offset = offset
4828 
    args.limit = limit
4829 
    args.write(self._oprot)
4830 
    self._oprot.writeMessageEnd()
4831 
    self._oprot.trans.flush()
4832 
 
4833 
  def recv_getAmazonListedItems(self, ):
4834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4835 
    if mtype == TMessageType.EXCEPTION:
4836 
      x = TApplicationException()
4837 
      x.read(self._iprot)
4838 
      self._iprot.readMessageEnd()
4839 
      raise x
4840 
    result = getAmazonListedItems_result()
4841 
    result.read(self._iprot)
4842 
    self._iprot.readMessageEnd()
4843 
    if result.success is not None:
4844 
      return result.success
4845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4846 
 
8168 kshitij.so 4847 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4848 
    """
4849 
    Parameters:
4850 
     - amazonlisted
4851 
    """
4852 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4853 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4854 
 
8168 kshitij.so 4855 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4856 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4857 
    args = updateAmazonAttributesInBulk_args()
4858 
    args.amazonlisted = amazonlisted
4859 
    args.write(self._oprot)
4860 
    self._oprot.writeMessageEnd()
4861 
    self._oprot.trans.flush()
4862 
 
4863 
  def recv_updateAmazonAttributesInBulk(self, ):
4864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4865 
    if mtype == TMessageType.EXCEPTION:
4866 
      x = TApplicationException()
4867 
      x.read(self._iprot)
4868 
      self._iprot.readMessageEnd()
4869 
      raise x
4870 
    result = updateAmazonAttributesInBulk_result()
4871 
    result.read(self._iprot)
4872 
    self._iprot.readMessageEnd()
4873 
    if result.success is not None:
4874 
      return result.success
4875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4876 
 
8379 vikram.rag 4877 
  def getAllItemstoListOnFba(self, ):
4878 
    self.send_getAllItemstoListOnFba()
4879 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4880 
 
8379 vikram.rag 4881 
  def send_getAllItemstoListOnFba(self, ):
4882 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4883 
    args = getAllItemstoListOnFba_args()
4884 
    args.write(self._oprot)
4885 
    self._oprot.writeMessageEnd()
4886 
    self._oprot.trans.flush()
4887 
 
4888 
  def recv_getAllItemstoListOnFba(self, ):
4889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4890 
    if mtype == TMessageType.EXCEPTION:
4891 
      x = TApplicationException()
4892 
      x.read(self._iprot)
4893 
      self._iprot.readMessageEnd()
4894 
      raise x
4895 
    result = getAllItemstoListOnFba_result()
4896 
    result.read(self._iprot)
4897 
    self._iprot.readMessageEnd()
4898 
    if result.success is not None:
4899 
      return result.success
4900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4901 
 
4902 
  def getAllItemstoListOnNonFba(self, ):
4903 
    self.send_getAllItemstoListOnNonFba()
4904 
    return self.recv_getAllItemstoListOnNonFba()
4905 
 
4906 
  def send_getAllItemstoListOnNonFba(self, ):
4907 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4908 
    args = getAllItemstoListOnNonFba_args()
4909 
    args.write(self._oprot)
4910 
    self._oprot.writeMessageEnd()
4911 
    self._oprot.trans.flush()
4912 
 
4913 
  def recv_getAllItemstoListOnNonFba(self, ):
4914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4915 
    if mtype == TMessageType.EXCEPTION:
4916 
      x = TApplicationException()
4917 
      x.read(self._iprot)
4918 
      self._iprot.readMessageEnd()
4919 
      raise x
4920 
    result = getAllItemstoListOnNonFba_result()
4921 
    result.read(self._iprot)
4922 
    self._iprot.readMessageEnd()
4923 
    if result.success is not None:
4924 
      return result.success
4925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4926 
 
8619 kshitij.so 4927 
  def updateAsin(self, item):
4928 
    """
4929 
    Parameters:
4930 
     - item
4931 
    """
4932 
    self.send_updateAsin(item)
4933 
    self.recv_updateAsin()
8616 vikram.rag 4934 
 
8619 kshitij.so 4935 
  def send_updateAsin(self, item):
4936 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4937 
    args = updateAsin_args()
4938 
    args.item = item
4939 
    args.write(self._oprot)
4940 
    self._oprot.writeMessageEnd()
4941 
    self._oprot.trans.flush()
4942 
 
4943 
  def recv_updateAsin(self, ):
4944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4945 
    if mtype == TMessageType.EXCEPTION:
4946 
      x = TApplicationException()
4947 
      x.read(self._iprot)
4948 
      self._iprot.readMessageEnd()
4949 
      raise x
4950 
    result = updateAsin_result()
4951 
    result.read(self._iprot)
4952 
    self._iprot.readMessageEnd()
4953 
    return
4954 
 
8739 vikram.rag 4955 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4956 
    """
4957 
    Parameters:
4958 
     - snapdealitem
4959 
    """
4960 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4961 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4962 
 
8739 vikram.rag 4963 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4964 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4965 
    args = addOrUpdateSnapdealItem_args()
4966 
    args.snapdealitem = snapdealitem
4967 
    args.write(self._oprot)
4968 
    self._oprot.writeMessageEnd()
4969 
    self._oprot.trans.flush()
4970 
 
4971 
  def recv_addOrUpdateSnapdealItem(self, ):
4972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4973 
    if mtype == TMessageType.EXCEPTION:
4974 
      x = TApplicationException()
4975 
      x.read(self._iprot)
4976 
      self._iprot.readMessageEnd()
4977 
      raise x
4978 
    result = addOrUpdateSnapdealItem_result()
4979 
    result.read(self._iprot)
4980 
    self._iprot.readMessageEnd()
4981 
    if result.success is not None:
4982 
      return result.success
4983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4984 
 
4985 
  def getSnapdealItem(self, item_id):
4986 
    """
4987 
    Parameters:
4988 
     - item_id
4989 
    """
4990 
    self.send_getSnapdealItem(item_id)
4991 
    return self.recv_getSnapdealItem()
4992 
 
4993 
  def send_getSnapdealItem(self, item_id):
4994 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4995 
    args = getSnapdealItem_args()
4996 
    args.item_id = item_id
4997 
    args.write(self._oprot)
4998 
    self._oprot.writeMessageEnd()
4999 
    self._oprot.trans.flush()
5000 
 
5001 
  def recv_getSnapdealItem(self, ):
5002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5003 
    if mtype == TMessageType.EXCEPTION:
5004 
      x = TApplicationException()
5005 
      x.read(self._iprot)
5006 
      self._iprot.readMessageEnd()
5007 
      raise x
5008 
    result = getSnapdealItem_result()
5009 
    result.read(self._iprot)
5010 
    self._iprot.readMessageEnd()
5011 
    if result.success is not None:
5012 
      return result.success
5013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
5014 
 
9242 kshitij.so 5015 
  def getSnapdealItemDetails(self, item_id):
5016 
    """
5017 
    Parameters:
5018 
     - item_id
5019 
    """
5020 
    self.send_getSnapdealItemDetails(item_id)
5021 
    return self.recv_getSnapdealItemDetails()
5022 
 
5023 
  def send_getSnapdealItemDetails(self, item_id):
5024 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
5025 
    args = getSnapdealItemDetails_args()
5026 
    args.item_id = item_id
5027 
    args.write(self._oprot)
5028 
    self._oprot.writeMessageEnd()
5029 
    self._oprot.trans.flush()
5030 
 
5031 
  def recv_getSnapdealItemDetails(self, ):
5032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5033 
    if mtype == TMessageType.EXCEPTION:
5034 
      x = TApplicationException()
5035 
      x.read(self._iprot)
5036 
      self._iprot.readMessageEnd()
5037 
      raise x
5038 
    result = getSnapdealItemDetails_result()
5039 
    result.read(self._iprot)
5040 
    self._iprot.readMessageEnd()
5041 
    if result.success is not None:
5042 
      return result.success
5043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
5044 
 
8739 vikram.rag 5045 
  def getAllSnapdealItems(self, ):
5046 
    self.send_getAllSnapdealItems()
5047 
    return self.recv_getAllSnapdealItems()
5048 
 
5049 
  def send_getAllSnapdealItems(self, ):
5050 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
5051 
    args = getAllSnapdealItems_args()
5052 
    args.write(self._oprot)
5053 
    self._oprot.writeMessageEnd()
5054 
    self._oprot.trans.flush()
5055 
 
5056 
  def recv_getAllSnapdealItems(self, ):
5057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5058 
    if mtype == TMessageType.EXCEPTION:
5059 
      x = TApplicationException()
5060 
      x.read(self._iprot)
5061 
      self._iprot.readMessageEnd()
5062 
      raise x
5063 
    result = getAllSnapdealItems_result()
5064 
    result.read(self._iprot)
5065 
    self._iprot.readMessageEnd()
5066 
    if result.success is not None:
5067 
      return result.success
5068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
5069 
 
9242 kshitij.so 5070 
  def getSnapdealItems(self, offset, limit):
5071 
    """
5072 
    Parameters:
5073 
     - offset
5074 
     - limit
5075 
    """
5076 
    self.send_getSnapdealItems(offset, limit)
5077 
    return self.recv_getSnapdealItems()
8739 vikram.rag 5078 
 
9242 kshitij.so 5079 
  def send_getSnapdealItems(self, offset, limit):
5080 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
5081 
    args = getSnapdealItems_args()
5082 
    args.offset = offset
5083 
    args.limit = limit
5084 
    args.write(self._oprot)
5085 
    self._oprot.writeMessageEnd()
5086 
    self._oprot.trans.flush()
5087 
 
5088 
  def recv_getSnapdealItems(self, ):
5089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5090 
    if mtype == TMessageType.EXCEPTION:
5091 
      x = TApplicationException()
5092 
      x.read(self._iprot)
5093 
      self._iprot.readMessageEnd()
5094 
      raise x
5095 
    result = getSnapdealItems_result()
5096 
    result.read(self._iprot)
5097 
    self._iprot.readMessageEnd()
5098 
    if result.success is not None:
5099 
      return result.success
5100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
5101 
 
5102 
  def searchSnapdealItems(self, searchTerm, offset, limit):
5103 
    """
5104 
    Parameters:
5105 
     - searchTerm
5106 
     - offset
5107 
     - limit
5108 
    """
5109 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
5110 
    return self.recv_searchSnapdealItems()
5111 
 
5112 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
5113 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
5114 
    args = searchSnapdealItems_args()
5115 
    args.searchTerm = searchTerm
5116 
    args.offset = offset
5117 
    args.limit = limit
5118 
    args.write(self._oprot)
5119 
    self._oprot.writeMessageEnd()
5120 
    self._oprot.trans.flush()
5121 
 
5122 
  def recv_searchSnapdealItems(self, ):
5123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5124 
    if mtype == TMessageType.EXCEPTION:
5125 
      x = TApplicationException()
5126 
      x.read(self._iprot)
5127 
      self._iprot.readMessageEnd()
5128 
      raise x
5129 
    result = searchSnapdealItems_result()
5130 
    result.read(self._iprot)
5131 
    self._iprot.readMessageEnd()
5132 
    if result.success is not None:
5133 
      return result.success
5134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
5135 
 
5136 
  def getCountForSnapdealItems(self, ):
5137 
    self.send_getCountForSnapdealItems()
5138 
    return self.recv_getCountForSnapdealItems()
5139 
 
5140 
  def send_getCountForSnapdealItems(self, ):
5141 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
5142 
    args = getCountForSnapdealItems_args()
5143 
    args.write(self._oprot)
5144 
    self._oprot.writeMessageEnd()
5145 
    self._oprot.trans.flush()
5146 
 
5147 
  def recv_getCountForSnapdealItems(self, ):
5148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5149 
    if mtype == TMessageType.EXCEPTION:
5150 
      x = TApplicationException()
5151 
      x.read(self._iprot)
5152 
      self._iprot.readMessageEnd()
5153 
      raise x
5154 
    result = getCountForSnapdealItems_result()
5155 
    result.read(self._iprot)
5156 
    self._iprot.readMessageEnd()
5157 
    if result.success is not None:
5158 
      return result.success
5159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5160 
 
5161 
  def getSnapdealSearchResultCount(self, searchTerm):
5162 
    """
5163 
    Parameters:
5164 
     - searchTerm
5165 
    """
5166 
    self.send_getSnapdealSearchResultCount(searchTerm)
5167 
    return self.recv_getSnapdealSearchResultCount()
5168 
 
5169 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5170 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5171 
    args = getSnapdealSearchResultCount_args()
5172 
    args.searchTerm = searchTerm
5173 
    args.write(self._oprot)
5174 
    self._oprot.writeMessageEnd()
5175 
    self._oprot.trans.flush()
5176 
 
5177 
  def recv_getSnapdealSearchResultCount(self, ):
5178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5179 
    if mtype == TMessageType.EXCEPTION:
5180 
      x = TApplicationException()
5181 
      x.read(self._iprot)
5182 
      self._iprot.readMessageEnd()
5183 
      raise x
5184 
    result = getSnapdealSearchResultCount_result()
5185 
    result.read(self._iprot)
5186 
    self._iprot.readMessageEnd()
5187 
    if result.success is not None:
5188 
      return result.success
5189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5190 
 
9299 kshitij.so 5191 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5192 
    """
5193 
    Parameters:
5194 
     - itemId
5195 
     - insurerType
5196 
    """
5197 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5198 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5199 
 
9299 kshitij.so 5200 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5201 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5202 
    args = getPrefferedInsurerForItem_args()
5203 
    args.itemId = itemId
5204 
    args.insurerType = insurerType
5205 
    args.write(self._oprot)
5206 
    self._oprot.writeMessageEnd()
5207 
    self._oprot.trans.flush()
5208 
 
5209 
  def recv_getPrefferedInsurerForItem(self, ):
5210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5211 
    if mtype == TMessageType.EXCEPTION:
5212 
      x = TApplicationException()
5213 
      x.read(self._iprot)
5214 
      self._iprot.readMessageEnd()
5215 
      raise x
5216 
    result = getPrefferedInsurerForItem_result()
5217 
    result.read(self._iprot)
5218 
    self._iprot.readMessageEnd()
5219 
    if result.success is not None:
5220 
      return result.success
5221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5222 
 
9456 vikram.rag 5223 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5224 
    """
5225 
    Parameters:
5226 
     - skuAtSnapdeal
5227 
    """
5228 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5229 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5230 
 
9456 vikram.rag 5231 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5232 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5233 
    args = getSnapdealItembySkuAtSnapdeal_args()
5234 
    args.skuAtSnapdeal = skuAtSnapdeal
5235 
    args.write(self._oprot)
5236 
    self._oprot.writeMessageEnd()
5237 
    self._oprot.trans.flush()
5238 
 
5239 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5241 
    if mtype == TMessageType.EXCEPTION:
5242 
      x = TApplicationException()
5243 
      x.read(self._iprot)
5244 
      self._iprot.readMessageEnd()
5245 
      raise x
5246 
    result = getSnapdealItembySkuAtSnapdeal_result()
5247 
    result.read(self._iprot)
5248 
    self._iprot.readMessageEnd()
5249 
    if result.success is not None:
5250 
      return result.success
5251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5252 
 
9621 manish.sha 5253 
  def getProductFeedSubmit(self, catalogItemId):
5254 
    """
5255 
    Parameters:
5256 
     - catalogItemId
5257 
    """
5258 
    self.send_getProductFeedSubmit(catalogItemId)
5259 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5260 
 
9621 manish.sha 5261 
  def send_getProductFeedSubmit(self, catalogItemId):
5262 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5263 
    args = getProductFeedSubmit_args()
5264 
    args.catalogItemId = catalogItemId
5265 
    args.write(self._oprot)
5266 
    self._oprot.writeMessageEnd()
5267 
    self._oprot.trans.flush()
5268 
 
5269 
  def recv_getProductFeedSubmit(self, ):
5270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5271 
    if mtype == TMessageType.EXCEPTION:
5272 
      x = TApplicationException()
5273 
      x.read(self._iprot)
5274 
      self._iprot.readMessageEnd()
5275 
      raise x
5276 
    result = getProductFeedSubmit_result()
5277 
    result.read(self._iprot)
5278 
    self._iprot.readMessageEnd()
5279 
    if result.success is not None:
5280 
      return result.success
5281 
    if result.cex is not None:
5282 
      raise result.cex
5283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5284 
 
5285 
  def addProductFeedSubmit(self, productFeedSubmit):
5286 
    """
5287 
    Parameters:
5288 
     - productFeedSubmit
5289 
    """
5290 
    self.send_addProductFeedSubmit(productFeedSubmit)
5291 
    return self.recv_addProductFeedSubmit()
5292 
 
5293 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5294 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5295 
    args = addProductFeedSubmit_args()
5296 
    args.productFeedSubmit = productFeedSubmit
5297 
    args.write(self._oprot)
5298 
    self._oprot.writeMessageEnd()
5299 
    self._oprot.trans.flush()
5300 
 
5301 
  def recv_addProductFeedSubmit(self, ):
5302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5303 
    if mtype == TMessageType.EXCEPTION:
5304 
      x = TApplicationException()
5305 
      x.read(self._iprot)
5306 
      self._iprot.readMessageEnd()
5307 
      raise x
5308 
    result = addProductFeedSubmit_result()
5309 
    result.read(self._iprot)
5310 
    self._iprot.readMessageEnd()
5311 
    if result.success is not None:
5312 
      return result.success
5313 
    if result.cex is not None:
5314 
      raise result.cex
5315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5316 
 
5317 
  def updateProductFeedSubmit(self, productFeedSubmit):
5318 
    """
5319 
    Parameters:
5320 
     - productFeedSubmit
5321 
    """
5322 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5323 
    return self.recv_updateProductFeedSubmit()
5324 
 
5325 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5326 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5327 
    args = updateProductFeedSubmit_args()
5328 
    args.productFeedSubmit = productFeedSubmit
5329 
    args.write(self._oprot)
5330 
    self._oprot.writeMessageEnd()
5331 
    self._oprot.trans.flush()
5332 
 
5333 
  def recv_updateProductFeedSubmit(self, ):
5334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5335 
    if mtype == TMessageType.EXCEPTION:
5336 
      x = TApplicationException()
5337 
      x.read(self._iprot)
5338 
      self._iprot.readMessageEnd()
5339 
      raise x
5340 
    result = updateProductFeedSubmit_result()
5341 
    result.read(self._iprot)
5342 
    self._iprot.readMessageEnd()
5343 
    if result.success is not None:
5344 
      return result.success
5345 
    if result.cex is not None:
5346 
      raise result.cex
5347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5348 
 
5349 
  def deleteProductFeedSubmit(self, catalogItemId):
5350 
    """
5351 
    Parameters:
5352 
     - catalogItemId
5353 
    """
5354 
    self.send_deleteProductFeedSubmit(catalogItemId)
5355 
    return self.recv_deleteProductFeedSubmit()
5356 
 
5357 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5358 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5359 
    args = deleteProductFeedSubmit_args()
5360 
    args.catalogItemId = catalogItemId
5361 
    args.write(self._oprot)
5362 
    self._oprot.writeMessageEnd()
5363 
    self._oprot.trans.flush()
5364 
 
5365 
  def recv_deleteProductFeedSubmit(self, ):
5366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5367 
    if mtype == TMessageType.EXCEPTION:
5368 
      x = TApplicationException()
5369 
      x.read(self._iprot)
5370 
      self._iprot.readMessageEnd()
5371 
      raise x
5372 
    result = deleteProductFeedSubmit_result()
5373 
    result.read(self._iprot)
5374 
    self._iprot.readMessageEnd()
5375 
    if result.success is not None:
5376 
      return result.success
5377 
    if result.cex is not None:
5378 
      raise result.cex
5379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5380 
 
5381 
  def getAllProductFeedSubmit(self, ):
5382 
    self.send_getAllProductFeedSubmit()
5383 
    return self.recv_getAllProductFeedSubmit()
5384 
 
5385 
  def send_getAllProductFeedSubmit(self, ):
5386 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5387 
    args = getAllProductFeedSubmit_args()
5388 
    args.write(self._oprot)
5389 
    self._oprot.writeMessageEnd()
5390 
    self._oprot.trans.flush()
5391 
 
5392 
  def recv_getAllProductFeedSubmit(self, ):
5393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5394 
    if mtype == TMessageType.EXCEPTION:
5395 
      x = TApplicationException()
5396 
      x.read(self._iprot)
5397 
      self._iprot.readMessageEnd()
5398 
      raise x
5399 
    result = getAllProductFeedSubmit_result()
5400 
    result.read(self._iprot)
5401 
    self._iprot.readMessageEnd()
5402 
    if result.success is not None:
5403 
      return result.success
5404 
    if result.cex is not None:
5405 
      raise result.cex
5406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5407 
 
9724 kshitij.so 5408 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5409 
    """
5410 
    Parameters:
5411 
     - itemId
5412 
     - sourceId
5413 
    """
5414 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5415 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5416 
 
9724 kshitij.so 5417 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5418 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5419 
    args = getMarketplacedetailsForItem_args()
5420 
    args.itemId = itemId
5421 
    args.sourceId = sourceId
5422 
    args.write(self._oprot)
5423 
    self._oprot.writeMessageEnd()
5424 
    self._oprot.trans.flush()
5425 
 
5426 
  def recv_getMarketplacedetailsForItem(self, ):
5427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5428 
    if mtype == TMessageType.EXCEPTION:
5429 
      x = TApplicationException()
5430 
      x.read(self._iprot)
5431 
      self._iprot.readMessageEnd()
5432 
      raise x
5433 
    result = getMarketplacedetailsForItem_result()
5434 
    result.read(self._iprot)
5435 
    self._iprot.readMessageEnd()
5436 
    if result.success is not None:
5437 
      return result.success
5438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5439 
 
5440 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5441 
    """
5442 
    Parameters:
5443 
     - marketPlaceItem
5444 
    """
5445 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5446 
    return self.recv_updateMarketplaceAttributesForItem()
5447 
 
5448 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5449 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5450 
    args = updateMarketplaceAttributesForItem_args()
5451 
    args.marketPlaceItem = marketPlaceItem
5452 
    args.write(self._oprot)
5453 
    self._oprot.writeMessageEnd()
5454 
    self._oprot.trans.flush()
5455 
 
5456 
  def recv_updateMarketplaceAttributesForItem(self, ):
5457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5458 
    if mtype == TMessageType.EXCEPTION:
5459 
      x = TApplicationException()
5460 
      x.read(self._iprot)
5461 
      self._iprot.readMessageEnd()
5462 
      raise x
5463 
    result = updateMarketplaceAttributesForItem_result()
5464 
    result.read(self._iprot)
5465 
    self._iprot.readMessageEnd()
5466 
    if result.success is not None:
5467 
      return result.success
5468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5469 
 
9779 kshitij.so 5470 
  def getCostingForMarketplace(self, source, item_id):
5471 
    """
5472 
    Parameters:
5473 
     - source
5474 
     - item_id
5475 
    """
5476 
    self.send_getCostingForMarketplace(source, item_id)
5477 
    return self.recv_getCostingForMarketplace()
5478 
 
5479 
  def send_getCostingForMarketplace(self, source, item_id):
5480 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5481 
    args = getCostingForMarketplace_args()
5482 
    args.source = source
5483 
    args.item_id = item_id
5484 
    args.write(self._oprot)
5485 
    self._oprot.writeMessageEnd()
5486 
    self._oprot.trans.flush()
5487 
 
5488 
  def recv_getCostingForMarketplace(self, ):
5489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5490 
    if mtype == TMessageType.EXCEPTION:
5491 
      x = TApplicationException()
5492 
      x.read(self._iprot)
5493 
      self._iprot.readMessageEnd()
5494 
      raise x
5495 
    result = getCostingForMarketplace_result()
5496 
    result.read(self._iprot)
5497 
    self._iprot.readMessageEnd()
5498 
    if result.success is not None:
5499 
      return result.success
5500 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5501 
 
9776 vikram.rag 5502 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5503 
    """
5504 
    Parameters:
5505 
     - source
5506 
    """
5507 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5508 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5509 
 
9776 vikram.rag 5510 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5511 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5512 
    args = getMarketPlaceItemsForPriceUpdate_args()
5513 
    args.source = source
5514 
    args.write(self._oprot)
5515 
    self._oprot.writeMessageEnd()
5516 
    self._oprot.trans.flush()
5517 
 
5518 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5520 
    if mtype == TMessageType.EXCEPTION:
5521 
      x = TApplicationException()
5522 
      x.read(self._iprot)
5523 
      self._iprot.readMessageEnd()
5524 
      raise x
5525 
    result = getMarketPlaceItemsForPriceUpdate_result()
5526 
    result.read(self._iprot)
5527 
    self._iprot.readMessageEnd()
5528 
    if result.success is not None:
5529 
      return result.success
5530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5531 
 
9816 kshitij.so 5532 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5533 
    """
5534 
    Parameters:
5535 
     - skulist
5536 
     - timestamp
9816 kshitij.so 5537 
     - source
9776 vikram.rag 5538 
    """
9816 kshitij.so 5539 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5540 
    self.recv_updateMarketPlacePriceUpdateStatus()
5541 
 
9816 kshitij.so 5542 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5543 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5544 
    args = updateMarketPlacePriceUpdateStatus_args()
5545 
    args.skulist = skulist
5546 
    args.timestamp = timestamp
9816 kshitij.so 5547 
    args.source = source
9776 vikram.rag 5548 
    args.write(self._oprot)
5549 
    self._oprot.writeMessageEnd()
5550 
    self._oprot.trans.flush()
5551 
 
5552 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5554 
    if mtype == TMessageType.EXCEPTION:
5555 
      x = TApplicationException()
5556 
      x.read(self._iprot)
5557 
      self._iprot.readMessageEnd()
5558 
      raise x
5559 
    result = updateMarketPlacePriceUpdateStatus_result()
5560 
    result.read(self._iprot)
5561 
    self._iprot.readMessageEnd()
5562 
    return
5563 
 
9861 rajveer 5564 
  def updateItemHoldInventory(self, itemHoldMap):
5565 
    """
5566 
    Parameters:
5567 
     - itemHoldMap
5568 
    """
5569 
    self.send_updateItemHoldInventory(itemHoldMap)
5570 
    self.recv_updateItemHoldInventory()
9776 vikram.rag 5571 
 
9861 rajveer 5572 
  def send_updateItemHoldInventory(self, itemHoldMap):
5573 
    self._oprot.writeMessageBegin('updateItemHoldInventory', TMessageType.CALL, self._seqid)
5574 
    args = updateItemHoldInventory_args()
5575 
    args.itemHoldMap = itemHoldMap
5576 
    args.write(self._oprot)
5577 
    self._oprot.writeMessageEnd()
5578 
    self._oprot.trans.flush()
5579 
 
5580 
  def recv_updateItemHoldInventory(self, ):
5581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5582 
    if mtype == TMessageType.EXCEPTION:
5583 
      x = TApplicationException()
5584 
      x.read(self._iprot)
5585 
      self._iprot.readMessageEnd()
5586 
      raise x
5587 
    result = updateItemHoldInventory_result()
5588 
    result.read(self._iprot)
5589 
    self._iprot.readMessageEnd()
5590 
    return
5591 
 
9895 vikram.rag 5592 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5593 
    """
5594 
    Parameters:
5595 
     - item_id
5596 
     - vendor_id
5597 
     - nlc
5598 
    """
5599 
    self.send_updateNlcAtMarketplaces(item_id, vendor_id, nlc)
5600 
    self.recv_updateNlcAtMarketplaces()
9861 rajveer 5601 
 
9895 vikram.rag 5602 
  def send_updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5603 
    self._oprot.writeMessageBegin('updateNlcAtMarketplaces', TMessageType.CALL, self._seqid)
5604 
    args = updateNlcAtMarketplaces_args()
5605 
    args.item_id = item_id
5606 
    args.vendor_id = vendor_id
5607 
    args.nlc = nlc
5608 
    args.write(self._oprot)
5609 
    self._oprot.writeMessageEnd()
5610 
    self._oprot.trans.flush()
5611 
 
5612 
  def recv_updateNlcAtMarketplaces(self, ):
5613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5614 
    if mtype == TMessageType.EXCEPTION:
5615 
      x = TApplicationException()
5616 
      x.read(self._iprot)
5617 
      self._iprot.readMessageEnd()
5618 
      raise x
5619 
    result = updateNlcAtMarketplaces_result()
5620 
    result.read(self._iprot)
5621 
    self._iprot.readMessageEnd()
5622 
    return
5623 
 
9945 vikram.rag 5624 
  def getAllFlipkartItems(self, ):
5625 
    self.send_getAllFlipkartItems()
5626 
    return self.recv_getAllFlipkartItems()
9895 vikram.rag 5627 
 
9945 vikram.rag 5628 
  def send_getAllFlipkartItems(self, ):
5629 
    self._oprot.writeMessageBegin('getAllFlipkartItems', TMessageType.CALL, self._seqid)
5630 
    args = getAllFlipkartItems_args()
5631 
    args.write(self._oprot)
5632 
    self._oprot.writeMessageEnd()
5633 
    self._oprot.trans.flush()
5634 
 
5635 
  def recv_getAllFlipkartItems(self, ):
5636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5637 
    if mtype == TMessageType.EXCEPTION:
5638 
      x = TApplicationException()
5639 
      x.read(self._iprot)
5640 
      self._iprot.readMessageEnd()
5641 
      raise x
5642 
    result = getAllFlipkartItems_result()
5643 
    result.read(self._iprot)
5644 
    self._iprot.readMessageEnd()
5645 
    if result.success is not None:
5646 
      return result.success
5647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartItems failed: unknown result");
5648 
 
10097 kshitij.so 5649 
  def addOrUpdateFlipkartItem(self, flipkartitem):
5650 
    """
5651 
    Parameters:
5652 
     - flipkartitem
5653 
    """
5654 
    self.send_addOrUpdateFlipkartItem(flipkartitem)
5655 
    return self.recv_addOrUpdateFlipkartItem()
9945 vikram.rag 5656 
 
10097 kshitij.so 5657 
  def send_addOrUpdateFlipkartItem(self, flipkartitem):
5658 
    self._oprot.writeMessageBegin('addOrUpdateFlipkartItem', TMessageType.CALL, self._seqid)
5659 
    args = addOrUpdateFlipkartItem_args()
5660 
    args.flipkartitem = flipkartitem
5661 
    args.write(self._oprot)
5662 
    self._oprot.writeMessageEnd()
5663 
    self._oprot.trans.flush()
5664 
 
5665 
  def recv_addOrUpdateFlipkartItem(self, ):
5666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5667 
    if mtype == TMessageType.EXCEPTION:
5668 
      x = TApplicationException()
5669 
      x.read(self._iprot)
5670 
      self._iprot.readMessageEnd()
5671 
      raise x
5672 
    result = addOrUpdateFlipkartItem_result()
5673 
    result.read(self._iprot)
5674 
    self._iprot.readMessageEnd()
5675 
    if result.success is not None:
5676 
      return result.success
5677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateFlipkartItem failed: unknown result");
5678 
 
5679 
  def getFlipkartItem(self, item_id):
5680 
    """
5681 
    Parameters:
5682 
     - item_id
5683 
    """
5684 
    self.send_getFlipkartItem(item_id)
5685 
    return self.recv_getFlipkartItem()
5686 
 
5687 
  def send_getFlipkartItem(self, item_id):
5688 
    self._oprot.writeMessageBegin('getFlipkartItem', TMessageType.CALL, self._seqid)
5689 
    args = getFlipkartItem_args()
5690 
    args.item_id = item_id
5691 
    args.write(self._oprot)
5692 
    self._oprot.writeMessageEnd()
5693 
    self._oprot.trans.flush()
5694 
 
5695 
  def recv_getFlipkartItem(self, ):
5696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5697 
    if mtype == TMessageType.EXCEPTION:
5698 
      x = TApplicationException()
5699 
      x.read(self._iprot)
5700 
      self._iprot.readMessageEnd()
5701 
      raise x
5702 
    result = getFlipkartItem_result()
5703 
    result.read(self._iprot)
5704 
    self._iprot.readMessageEnd()
5705 
    if result.success is not None:
5706 
      return result.success
5707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItem failed: unknown result");
5708 
 
5709 
  def getFlipkartItemDetails(self, item_id):
5710 
    """
5711 
    Parameters:
5712 
     - item_id
5713 
    """
5714 
    self.send_getFlipkartItemDetails(item_id)
5715 
    return self.recv_getFlipkartItemDetails()
5716 
 
5717 
  def send_getFlipkartItemDetails(self, item_id):
5718 
    self._oprot.writeMessageBegin('getFlipkartItemDetails', TMessageType.CALL, self._seqid)
5719 
    args = getFlipkartItemDetails_args()
5720 
    args.item_id = item_id
5721 
    args.write(self._oprot)
5722 
    self._oprot.writeMessageEnd()
5723 
    self._oprot.trans.flush()
5724 
 
5725 
  def recv_getFlipkartItemDetails(self, ):
5726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5727 
    if mtype == TMessageType.EXCEPTION:
5728 
      x = TApplicationException()
5729 
      x.read(self._iprot)
5730 
      self._iprot.readMessageEnd()
5731 
      raise x
5732 
    result = getFlipkartItemDetails_result()
5733 
    result.read(self._iprot)
5734 
    self._iprot.readMessageEnd()
5735 
    if result.success is not None:
5736 
      return result.success
5737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemDetails failed: unknown result");
5738 
 
5739 
  def getFlipkartItems(self, offset, limit):
5740 
    """
5741 
    Parameters:
5742 
     - offset
5743 
     - limit
5744 
    """
5745 
    self.send_getFlipkartItems(offset, limit)
5746 
    return self.recv_getFlipkartItems()
5747 
 
5748 
  def send_getFlipkartItems(self, offset, limit):
5749 
    self._oprot.writeMessageBegin('getFlipkartItems', TMessageType.CALL, self._seqid)
5750 
    args = getFlipkartItems_args()
5751 
    args.offset = offset
5752 
    args.limit = limit
5753 
    args.write(self._oprot)
5754 
    self._oprot.writeMessageEnd()
5755 
    self._oprot.trans.flush()
5756 
 
5757 
  def recv_getFlipkartItems(self, ):
5758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5759 
    if mtype == TMessageType.EXCEPTION:
5760 
      x = TApplicationException()
5761 
      x.read(self._iprot)
5762 
      self._iprot.readMessageEnd()
5763 
      raise x
5764 
    result = getFlipkartItems_result()
5765 
    result.read(self._iprot)
5766 
    self._iprot.readMessageEnd()
5767 
    if result.success is not None:
5768 
      return result.success
5769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItems failed: unknown result");
5770 
 
5771 
  def searchFlipkartItems(self, searchTerm, offset, limit):
5772 
    """
5773 
    Parameters:
5774 
     - searchTerm
5775 
     - offset
5776 
     - limit
5777 
    """
5778 
    self.send_searchFlipkartItems(searchTerm, offset, limit)
5779 
    return self.recv_searchFlipkartItems()
5780 
 
5781 
  def send_searchFlipkartItems(self, searchTerm, offset, limit):
5782 
    self._oprot.writeMessageBegin('searchFlipkartItems', TMessageType.CALL, self._seqid)
5783 
    args = searchFlipkartItems_args()
5784 
    args.searchTerm = searchTerm
5785 
    args.offset = offset
5786 
    args.limit = limit
5787 
    args.write(self._oprot)
5788 
    self._oprot.writeMessageEnd()
5789 
    self._oprot.trans.flush()
5790 
 
5791 
  def recv_searchFlipkartItems(self, ):
5792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5793 
    if mtype == TMessageType.EXCEPTION:
5794 
      x = TApplicationException()
5795 
      x.read(self._iprot)
5796 
      self._iprot.readMessageEnd()
5797 
      raise x
5798 
    result = searchFlipkartItems_result()
5799 
    result.read(self._iprot)
5800 
    self._iprot.readMessageEnd()
5801 
    if result.success is not None:
5802 
      return result.success
5803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchFlipkartItems failed: unknown result");
5804 
 
5805 
  def getCountForFlipkartItems(self, ):
5806 
    self.send_getCountForFlipkartItems()
5807 
    return self.recv_getCountForFlipkartItems()
5808 
 
5809 
  def send_getCountForFlipkartItems(self, ):
5810 
    self._oprot.writeMessageBegin('getCountForFlipkartItems', TMessageType.CALL, self._seqid)
5811 
    args = getCountForFlipkartItems_args()
5812 
    args.write(self._oprot)
5813 
    self._oprot.writeMessageEnd()
5814 
    self._oprot.trans.flush()
5815 
 
5816 
  def recv_getCountForFlipkartItems(self, ):
5817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5818 
    if mtype == TMessageType.EXCEPTION:
5819 
      x = TApplicationException()
5820 
      x.read(self._iprot)
5821 
      self._iprot.readMessageEnd()
5822 
      raise x
5823 
    result = getCountForFlipkartItems_result()
5824 
    result.read(self._iprot)
5825 
    self._iprot.readMessageEnd()
5826 
    if result.success is not None:
5827 
      return result.success
5828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForFlipkartItems failed: unknown result");
5829 
 
5830 
  def getFlipkartSearchResultCount(self, searchTerm):
5831 
    """
5832 
    Parameters:
5833 
     - searchTerm
5834 
    """
5835 
    self.send_getFlipkartSearchResultCount(searchTerm)
5836 
    return self.recv_getFlipkartSearchResultCount()
5837 
 
5838 
  def send_getFlipkartSearchResultCount(self, searchTerm):
5839 
    self._oprot.writeMessageBegin('getFlipkartSearchResultCount', TMessageType.CALL, self._seqid)
5840 
    args = getFlipkartSearchResultCount_args()
5841 
    args.searchTerm = searchTerm
5842 
    args.write(self._oprot)
5843 
    self._oprot.writeMessageEnd()
5844 
    self._oprot.trans.flush()
5845 
 
5846 
  def recv_getFlipkartSearchResultCount(self, ):
5847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5848 
    if mtype == TMessageType.EXCEPTION:
5849 
      x = TApplicationException()
5850 
      x.read(self._iprot)
5851 
      self._iprot.readMessageEnd()
5852 
      raise x
5853 
    result = getFlipkartSearchResultCount_result()
5854 
    result.read(self._iprot)
5855 
    self._iprot.readMessageEnd()
5856 
    if result.success is not None:
5857 
      return result.success
5858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartSearchResultCount failed: unknown result");
5859 
 
5860 
  def getAllFkItems(self, ):
5861 
    self.send_getAllFkItems()
5862 
    return self.recv_getAllFkItems()
5863 
 
5864 
  def send_getAllFkItems(self, ):
5865 
    self._oprot.writeMessageBegin('getAllFkItems', TMessageType.CALL, self._seqid)
5866 
    args = getAllFkItems_args()
5867 
    args.write(self._oprot)
5868 
    self._oprot.writeMessageEnd()
5869 
    self._oprot.trans.flush()
5870 
 
5871 
  def recv_getAllFkItems(self, ):
5872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5873 
    if mtype == TMessageType.EXCEPTION:
5874 
      x = TApplicationException()
5875 
      x.read(self._iprot)
5876 
      self._iprot.readMessageEnd()
5877 
      raise x
5878 
    result = getAllFkItems_result()
5879 
    result.read(self._iprot)
5880 
    self._iprot.readMessageEnd()
5881 
    if result.success is not None:
5882 
      return result.success
5883 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFkItems failed: unknown result");
5884 
 
10140 vikram.rag 5885 
  def getFlipkartItemBySkyAtFlipkart(self, sku):
5886 
    """
5887 
    Parameters:
5888 
     - sku
5889 
    """
5890 
    self.send_getFlipkartItemBySkyAtFlipkart(sku)
5891 
    return self.recv_getFlipkartItemBySkyAtFlipkart()
10097 kshitij.so 5892 
 
10140 vikram.rag 5893 
  def send_getFlipkartItemBySkyAtFlipkart(self, sku):
5894 
    self._oprot.writeMessageBegin('getFlipkartItemBySkyAtFlipkart', TMessageType.CALL, self._seqid)
5895 
    args = getFlipkartItemBySkyAtFlipkart_args()
5896 
    args.sku = sku
5897 
    args.write(self._oprot)
5898 
    self._oprot.writeMessageEnd()
5899 
    self._oprot.trans.flush()
5900 
 
5901 
  def recv_getFlipkartItemBySkyAtFlipkart(self, ):
5902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5903 
    if mtype == TMessageType.EXCEPTION:
5904 
      x = TApplicationException()
5905 
      x.read(self._iprot)
5906 
      self._iprot.readMessageEnd()
5907 
      raise x
5908 
    result = getFlipkartItemBySkyAtFlipkart_result()
5909 
    result.read(self._iprot)
5910 
    self._iprot.readMessageEnd()
5911 
    if result.success is not None:
5912 
      return result.success
5913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemBySkyAtFlipkart failed: unknown result");
5914 
 
11015 kshitij.so 5915 
  def getMarketplaceHistory(self, source, offset, itemId):
5916 
    """
5917 
    Parameters:
5918 
     - source
5919 
     - offset
5920 
     - itemId
5921 
    """
5922 
    self.send_getMarketplaceHistory(source, offset, itemId)
5923 
    return self.recv_getMarketplaceHistory()
5924 
 
5925 
  def send_getMarketplaceHistory(self, source, offset, itemId):
5926 
    self._oprot.writeMessageBegin('getMarketplaceHistory', TMessageType.CALL, self._seqid)
5927 
    args = getMarketplaceHistory_args()
5928 
    args.source = source
5929 
    args.offset = offset
5930 
    args.itemId = itemId
5931 
    args.write(self._oprot)
5932 
    self._oprot.writeMessageEnd()
5933 
    self._oprot.trans.flush()
5934 
 
5935 
  def recv_getMarketplaceHistory(self, ):
5936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5937 
    if mtype == TMessageType.EXCEPTION:
5938 
      x = TApplicationException()
5939 
      x.read(self._iprot)
5940 
      self._iprot.readMessageEnd()
5941 
      raise x
5942 
    result = getMarketplaceHistory_result()
5943 
    result.read(self._iprot)
5944 
    self._iprot.readMessageEnd()
5945 
    if result.success is not None:
5946 
      return result.success
5947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistory failed: unknown result");
5948 
 
10909 vikram.rag 5949 
  def getAllFbbListedItems(self, ):
5950 
    self.send_getAllFbbListedItems()
5951 
    return self.recv_getAllFbbListedItems()
10140 vikram.rag 5952 
 
10909 vikram.rag 5953 
  def send_getAllFbbListedItems(self, ):
5954 
    self._oprot.writeMessageBegin('getAllFbbListedItems', TMessageType.CALL, self._seqid)
5955 
    args = getAllFbbListedItems_args()
5956 
    args.write(self._oprot)
5957 
    self._oprot.writeMessageEnd()
5958 
    self._oprot.trans.flush()
5959 
 
5960 
  def recv_getAllFbbListedItems(self, ):
5961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5962 
    if mtype == TMessageType.EXCEPTION:
5963 
      x = TApplicationException()
5964 
      x.read(self._iprot)
5965 
      self._iprot.readMessageEnd()
5966 
      raise x
5967 
    result = getAllFbbListedItems_result()
5968 
    result.read(self._iprot)
5969 
    self._iprot.readMessageEnd()
5970 
    if result.success is not None:
5971 
      return result.success
5972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbListedItems failed: unknown result");
5973 
 
10924 vikram.rag 5974 
  def getAllFbbPricingItems(self, ):
5975 
    self.send_getAllFbbPricingItems()
5976 
    return self.recv_getAllFbbPricingItems()
10909 vikram.rag 5977 
 
10924 vikram.rag 5978 
  def send_getAllFbbPricingItems(self, ):
5979 
    self._oprot.writeMessageBegin('getAllFbbPricingItems', TMessageType.CALL, self._seqid)
5980 
    args = getAllFbbPricingItems_args()
5981 
    args.write(self._oprot)
5982 
    self._oprot.writeMessageEnd()
5983 
    self._oprot.trans.flush()
5984 
 
5985 
  def recv_getAllFbbPricingItems(self, ):
5986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5987 
    if mtype == TMessageType.EXCEPTION:
5988 
      x = TApplicationException()
5989 
      x.read(self._iprot)
5990 
      self._iprot.readMessageEnd()
5991 
      raise x
5992 
    result = getAllFbbPricingItems_result()
5993 
    result.read(self._iprot)
5994 
    self._iprot.readMessageEnd()
5995 
    if result.success is not None:
5996 
      return result.success
5997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbPricingItems failed: unknown result");
5998 
 
11015 kshitij.so 5999 
  def getCountForMarketplaceHistory(self, source, itemId):
6000 
    """
6001 
    Parameters:
6002 
     - source
6003 
     - itemId
6004 
    """
6005 
    self.send_getCountForMarketplaceHistory(source, itemId)
6006 
    return self.recv_getCountForMarketplaceHistory()
10924 vikram.rag 6007 
 
11015 kshitij.so 6008 
  def send_getCountForMarketplaceHistory(self, source, itemId):
6009 
    self._oprot.writeMessageBegin('getCountForMarketplaceHistory', TMessageType.CALL, self._seqid)
6010 
    args = getCountForMarketplaceHistory_args()
6011 
    args.source = source
6012 
    args.itemId = itemId
6013 
    args.write(self._oprot)
6014 
    self._oprot.writeMessageEnd()
6015 
    self._oprot.trans.flush()
6016 
 
6017 
  def recv_getCountForMarketplaceHistory(self, ):
6018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6019 
    if mtype == TMessageType.EXCEPTION:
6020 
      x = TApplicationException()
6021 
      x.read(self._iprot)
6022 
      self._iprot.readMessageEnd()
6023 
      raise x
6024 
    result = getCountForMarketplaceHistory_result()
6025 
    result.read(self._iprot)
6026 
    self._iprot.readMessageEnd()
6027 
    if result.success is not None:
6028 
      return result.success
6029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForMarketplaceHistory failed: unknown result");
6030 
 
6031 
  def getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6032 
    """
6033 
    Parameters:
6034 
     - source
6035 
     - startDate
6036 
     - endDate
6037 
     - offset
6038 
     - limit
6039 
     - itemId
6040 
    """
6041 
    self.send_getMarketplaceHistoryByDate(source, startDate, endDate, offset, limit, itemId)
6042 
    return self.recv_getMarketplaceHistoryByDate()
6043 
 
6044 
  def send_getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6045 
    self._oprot.writeMessageBegin('getMarketplaceHistoryByDate', TMessageType.CALL, self._seqid)
6046 
    args = getMarketplaceHistoryByDate_args()
6047 
    args.source = source
6048 
    args.startDate = startDate
6049 
    args.endDate = endDate
6050 
    args.offset = offset
6051 
    args.limit = limit
6052 
    args.itemId = itemId
6053 
    args.write(self._oprot)
6054 
    self._oprot.writeMessageEnd()
6055 
    self._oprot.trans.flush()
6056 
 
6057 
  def recv_getMarketplaceHistoryByDate(self, ):
6058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6059 
    if mtype == TMessageType.EXCEPTION:
6060 
      x = TApplicationException()
6061 
      x.read(self._iprot)
6062 
      self._iprot.readMessageEnd()
6063 
      raise x
6064 
    result = getMarketplaceHistoryByDate_result()
6065 
    result.read(self._iprot)
6066 
    self._iprot.readMessageEnd()
6067 
    if result.success is not None:
6068 
      return result.success
6069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistoryByDate failed: unknown result");
6070 
 
11531 vikram.rag 6071 
  def getPrivateDealDetails(self, item_id):
6072 
    """
6073 
    Parameters:
6074 
     - item_id
6075 
    """
6076 
    self.send_getPrivateDealDetails(item_id)
6077 
    return self.recv_getPrivateDealDetails()
11015 kshitij.so 6078 
 
11531 vikram.rag 6079 
  def send_getPrivateDealDetails(self, item_id):
6080 
    self._oprot.writeMessageBegin('getPrivateDealDetails', TMessageType.CALL, self._seqid)
6081 
    args = getPrivateDealDetails_args()
6082 
    args.item_id = item_id
6083 
    args.write(self._oprot)
6084 
    self._oprot.writeMessageEnd()
6085 
    self._oprot.trans.flush()
6086 
 
6087 
  def recv_getPrivateDealDetails(self, ):
6088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6089 
    if mtype == TMessageType.EXCEPTION:
6090 
      x = TApplicationException()
6091 
      x.read(self._iprot)
6092 
      self._iprot.readMessageEnd()
6093 
      raise x
6094 
    result = getPrivateDealDetails_result()
6095 
    result.read(self._iprot)
6096 
    self._iprot.readMessageEnd()
6097 
    if result.success is not None:
6098 
      return result.success
6099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealDetails failed: unknown result");
6100 
 
6101 
  def getPrivateDealItems(self, offset, limit):
6102 
    """
6103 
    Parameters:
6104 
     - offset
6105 
     - limit
6106 
    """
6107 
    self.send_getPrivateDealItems(offset, limit)
6108 
    return self.recv_getPrivateDealItems()
6109 
 
6110 
  def send_getPrivateDealItems(self, offset, limit):
6111 
    self._oprot.writeMessageBegin('getPrivateDealItems', TMessageType.CALL, self._seqid)
6112 
    args = getPrivateDealItems_args()
6113 
    args.offset = offset
6114 
    args.limit = limit
6115 
    args.write(self._oprot)
6116 
    self._oprot.writeMessageEnd()
6117 
    self._oprot.trans.flush()
6118 
 
6119 
  def recv_getPrivateDealItems(self, ):
6120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6121 
    if mtype == TMessageType.EXCEPTION:
6122 
      x = TApplicationException()
6123 
      x.read(self._iprot)
6124 
      self._iprot.readMessageEnd()
6125 
      raise x
6126 
    result = getPrivateDealItems_result()
6127 
    result.read(self._iprot)
6128 
    self._iprot.readMessageEnd()
6129 
    if result.success is not None:
6130 
      return result.success
6131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealItems failed: unknown result");
6132 
 
11653 amit.gupta 6133 
  def getAllActivePrivateDeals(self, itemIds, daysDelta):
6134 
    """
6135 
    Parameters:
6136 
     - itemIds
6137 
     - daysDelta
6138 
    """
6139 
    self.send_getAllActivePrivateDeals(itemIds, daysDelta)
11592 amit.gupta 6140 
    return self.recv_getAllActivePrivateDeals()
6141 
 
11653 amit.gupta 6142 
  def send_getAllActivePrivateDeals(self, itemIds, daysDelta):
11592 amit.gupta 6143 
    self._oprot.writeMessageBegin('getAllActivePrivateDeals', TMessageType.CALL, self._seqid)
6144 
    args = getAllActivePrivateDeals_args()
11653 amit.gupta 6145 
    args.itemIds = itemIds
6146 
    args.daysDelta = daysDelta
11592 amit.gupta 6147 
    args.write(self._oprot)
6148 
    self._oprot.writeMessageEnd()
6149 
    self._oprot.trans.flush()
6150 
 
6151 
  def recv_getAllActivePrivateDeals(self, ):
6152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6153 
    if mtype == TMessageType.EXCEPTION:
6154 
      x = TApplicationException()
6155 
      x.read(self._iprot)
6156 
      self._iprot.readMessageEnd()
6157 
      raise x
6158 
    result = getAllActivePrivateDeals_result()
6159 
    result.read(self._iprot)
6160 
    self._iprot.readMessageEnd()
6161 
    if result.success is not None:
6162 
      return result.success
6163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllActivePrivateDeals failed: unknown result");
6164 
 
11531 vikram.rag 6165 
  def addOrUpdatePrivateDeal(self, privateDeal):
6166 
    """
6167 
    Parameters:
6168 
     - privateDeal
6169 
    """
6170 
    self.send_addOrUpdatePrivateDeal(privateDeal)
6171 
    return self.recv_addOrUpdatePrivateDeal()
6172 
 
6173 
  def send_addOrUpdatePrivateDeal(self, privateDeal):
6174 
    self._oprot.writeMessageBegin('addOrUpdatePrivateDeal', TMessageType.CALL, self._seqid)
6175 
    args = addOrUpdatePrivateDeal_args()
6176 
    args.privateDeal = privateDeal
6177 
    args.write(self._oprot)
6178 
    self._oprot.writeMessageEnd()
6179 
    self._oprot.trans.flush()
6180 
 
6181 
  def recv_addOrUpdatePrivateDeal(self, ):
6182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6183 
    if mtype == TMessageType.EXCEPTION:
6184 
      x = TApplicationException()
6185 
      x.read(self._iprot)
6186 
      self._iprot.readMessageEnd()
6187 
      raise x
6188 
    result = addOrUpdatePrivateDeal_result()
6189 
    result.read(self._iprot)
6190 
    self._iprot.readMessageEnd()
6191 
    if result.success is not None:
6192 
      return result.success
6193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdatePrivateDeal failed: unknown result");
6194 
 
11635 vikram.rag 6195 
  def getPrivateDealsCatalogIds(self, beginIndex, totalItems):
6196 
    """
6197 
    Parameters:
6198 
     - beginIndex
6199 
     - totalItems
6200 
    """
6201 
    self.send_getPrivateDealsCatalogIds(beginIndex, totalItems)
6202 
    return self.recv_getPrivateDealsCatalogIds()
11531 vikram.rag 6203 
 
11635 vikram.rag 6204 
  def send_getPrivateDealsCatalogIds(self, beginIndex, totalItems):
6205 
    self._oprot.writeMessageBegin('getPrivateDealsCatalogIds', TMessageType.CALL, self._seqid)
6206 
    args = getPrivateDealsCatalogIds_args()
6207 
    args.beginIndex = beginIndex
6208 
    args.totalItems = totalItems
6209 
    args.write(self._oprot)
6210 
    self._oprot.writeMessageEnd()
6211 
    self._oprot.trans.flush()
6212 
 
6213 
  def recv_getPrivateDealsCatalogIds(self, ):
6214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6215 
    if mtype == TMessageType.EXCEPTION:
6216 
      x = TApplicationException()
6217 
      x.read(self._iprot)
6218 
      self._iprot.readMessageEnd()
6219 
      raise x
6220 
    result = getPrivateDealsCatalogIds_result()
6221 
    result.read(self._iprot)
6222 
    self._iprot.readMessageEnd()
6223 
    if result.success is not None:
6224 
      return result.success
6225 
    if result.cex is not None:
6226 
      raise result.cex
6227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealsCatalogIds failed: unknown result");
6228 
 
11645 amit.gupta 6229 
  def getPrivateDealsCount(self, ):
6230 
    self.send_getPrivateDealsCount()
6231 
    return self.recv_getPrivateDealsCount()
11635 vikram.rag 6232 
 
11645 amit.gupta 6233 
  def send_getPrivateDealsCount(self, ):
6234 
    self._oprot.writeMessageBegin('getPrivateDealsCount', TMessageType.CALL, self._seqid)
6235 
    args = getPrivateDealsCount_args()
6236 
    args.write(self._oprot)
6237 
    self._oprot.writeMessageEnd()
6238 
    self._oprot.trans.flush()
6239 
 
6240 
  def recv_getPrivateDealsCount(self, ):
6241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6242 
    if mtype == TMessageType.EXCEPTION:
6243 
      x = TApplicationException()
6244 
      x.read(self._iprot)
6245 
      self._iprot.readMessageEnd()
6246 
      raise x
6247 
    result = getPrivateDealsCount_result()
6248 
    result.read(self._iprot)
6249 
    self._iprot.readMessageEnd()
6250 
    if result.success is not None:
6251 
      return result.success
6252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealsCount failed: unknown result");
6253 
 
6254 
 
5944 mandeep.dh 6255 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
6256 
  def __init__(self, handler):
6257 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
6258 
    self._processMap["addItem"] = Processor.process_addItem
6259 
    self._processMap["updateItem"] = Processor.process_updateItem
6260 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 6261 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 6262 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
6263 
    self._processMap["startItemOn"] = Processor.process_startItemOn
6264 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
6265 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
6266 
    self._processMap["getItem"] = Processor.process_getItem
6267 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
6268 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
6269 
    self._processMap["getAllItems"] = Processor.process_getAllItems
6270 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
6271 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
6272 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
6273 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
6274 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
6275 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
6276 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
6277 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
6278 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
6279 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
6280 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
6281 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
6282 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
6283 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
6284 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
6285 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
6286 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
6287 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
6288 
    self._processMap["addCategory"] = Processor.process_addCategory
6289 
    self._processMap["getCategory"] = Processor.process_getCategory
6290 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
6291 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
6292 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 6293 
    self._processMap["addTag"] = Processor.process_addTag
6294 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
6295 
    self._processMap["deleteTag"] = Processor.process_deleteTag
6296 
    self._processMap["getAllTags"] = Processor.process_getAllTags
6297 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 6298 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 6299 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 6300 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 6301 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
6302 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
6303 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
6304 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 6305 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 6306 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 6307 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
6308 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 6309 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
6310 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
6311 
    self._processMap["addCampaign"] = Processor.process_addCampaign
6312 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
6313 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
6314 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 6315 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 6316 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
6317 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
6318 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
6319 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
6320 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
6321 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
6322 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
6323 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
6324 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
6325 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
6326 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
6327 
    self._processMap["getAllSources"] = Processor.process_getAllSources
6328 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
6329 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
6330 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
6331 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
6332 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
6333 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
6334 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
6335 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
6336 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
6337 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
6338 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
6339 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
6340 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
6341 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 6342 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
6343 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 6344 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 6345 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 6346 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
6347 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 6348 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 6349 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 6350 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
6351 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 6352 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
6353 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 6354 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 6355 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 6356 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 6357 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 6358 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
6359 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
6360 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 6361 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
6362 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
6363 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 6364 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
6365 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
6366 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 6367 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 6368 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 6369 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 6370 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
6371 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 6372 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
6373 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
6374 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 6375 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 6376 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 6377 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
6378 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 6379 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 6380 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
6381 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 6382 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 6383 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 6384 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
6385 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
6386 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
6387 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 6388 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 6389 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 6390 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
6391 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
6392 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
6393 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
6394 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 6395 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
6396 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 6397 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 6398 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
6399 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
9861 rajveer 6400 
    self._processMap["updateItemHoldInventory"] = Processor.process_updateItemHoldInventory
9895 vikram.rag 6401 
    self._processMap["updateNlcAtMarketplaces"] = Processor.process_updateNlcAtMarketplaces
9945 vikram.rag 6402 
    self._processMap["getAllFlipkartItems"] = Processor.process_getAllFlipkartItems
10097 kshitij.so 6403 
    self._processMap["addOrUpdateFlipkartItem"] = Processor.process_addOrUpdateFlipkartItem
6404 
    self._processMap["getFlipkartItem"] = Processor.process_getFlipkartItem
6405 
    self._processMap["getFlipkartItemDetails"] = Processor.process_getFlipkartItemDetails
6406 
    self._processMap["getFlipkartItems"] = Processor.process_getFlipkartItems
6407 
    self._processMap["searchFlipkartItems"] = Processor.process_searchFlipkartItems
6408 
    self._processMap["getCountForFlipkartItems"] = Processor.process_getCountForFlipkartItems
6409 
    self._processMap["getFlipkartSearchResultCount"] = Processor.process_getFlipkartSearchResultCount
6410 
    self._processMap["getAllFkItems"] = Processor.process_getAllFkItems
10140 vikram.rag 6411 
    self._processMap["getFlipkartItemBySkyAtFlipkart"] = Processor.process_getFlipkartItemBySkyAtFlipkart
11015 kshitij.so 6412 
    self._processMap["getMarketplaceHistory"] = Processor.process_getMarketplaceHistory
10909 vikram.rag 6413 
    self._processMap["getAllFbbListedItems"] = Processor.process_getAllFbbListedItems
10924 vikram.rag 6414 
    self._processMap["getAllFbbPricingItems"] = Processor.process_getAllFbbPricingItems
11015 kshitij.so 6415 
    self._processMap["getCountForMarketplaceHistory"] = Processor.process_getCountForMarketplaceHistory
6416 
    self._processMap["getMarketplaceHistoryByDate"] = Processor.process_getMarketplaceHistoryByDate
11531 vikram.rag 6417 
    self._processMap["getPrivateDealDetails"] = Processor.process_getPrivateDealDetails
6418 
    self._processMap["getPrivateDealItems"] = Processor.process_getPrivateDealItems
11592 amit.gupta 6419 
    self._processMap["getAllActivePrivateDeals"] = Processor.process_getAllActivePrivateDeals
11531 vikram.rag 6420 
    self._processMap["addOrUpdatePrivateDeal"] = Processor.process_addOrUpdatePrivateDeal
11635 vikram.rag 6421 
    self._processMap["getPrivateDealsCatalogIds"] = Processor.process_getPrivateDealsCatalogIds
11645 amit.gupta 6422 
    self._processMap["getPrivateDealsCount"] = Processor.process_getPrivateDealsCount
5944 mandeep.dh 6423 
 
6424 
  def process(self, iprot, oprot):
6425 
    (name, type, seqid) = iprot.readMessageBegin()
6426 
    if name not in self._processMap:
6427 
      iprot.skip(TType.STRUCT)
6428 
      iprot.readMessageEnd()
6429 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6430 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6431 
      x.write(oprot)
6432 
      oprot.writeMessageEnd()
6433 
      oprot.trans.flush()
6434 
      return
6435 
    else:
6436 
      self._processMap[name](self, seqid, iprot, oprot)
6437 
    return True
6438 
 
6439 
  def process_addItem(self, seqid, iprot, oprot):
6440 
    args = addItem_args()
6441 
    args.read(iprot)
6442 
    iprot.readMessageEnd()
6443 
    result = addItem_result()
6444 
    try:
6445 
      result.success = self._handler.addItem(args.item)
6446 
    except CatalogServiceException, cex:
6447 
      result.cex = cex
6448 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
6449 
    result.write(oprot)
6450 
    oprot.writeMessageEnd()
6451 
    oprot.trans.flush()
6452 
 
6453 
  def process_updateItem(self, seqid, iprot, oprot):
6454 
    args = updateItem_args()
6455 
    args.read(iprot)
6456 
    iprot.readMessageEnd()
6457 
    result = updateItem_result()
6458 
    try:
6459 
      result.success = self._handler.updateItem(args.item)
6460 
    except CatalogServiceException, cex:
6461 
      result.cex = cex
6462 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
6463 
    result.write(oprot)
6464 
    oprot.writeMessageEnd()
6465 
    oprot.trans.flush()
6466 
 
6467 
  def process_isActive(self, seqid, iprot, oprot):
6468 
    args = isActive_args()
6469 
    args.read(iprot)
6470 
    iprot.readMessageEnd()
6471 
    result = isActive_result()
6472 
    try:
6473 
      result.success = self._handler.isActive(args.itemId)
6474 
    except CatalogServiceException, isex:
6475 
      result.isex = isex
6476 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
6477 
    result.write(oprot)
6478 
    oprot.writeMessageEnd()
6479 
    oprot.trans.flush()
6480 
 
7438 amit.gupta 6481 
  def process_getItemsStatus(self, seqid, iprot, oprot):
6482 
    args = getItemsStatus_args()
6483 
    args.read(iprot)
6484 
    iprot.readMessageEnd()
6485 
    result = getItemsStatus_result()
6486 
    try:
6487 
      result.success = self._handler.getItemsStatus(args.itemIds)
6488 
    except CatalogServiceException, isex:
6489 
      result.isex = isex
6490 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
6491 
    result.write(oprot)
6492 
    oprot.writeMessageEnd()
6493 
    oprot.trans.flush()
6494 
 
5944 mandeep.dh 6495 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
6496 
    args = getItemStatusDescription_args()
6497 
    args.read(iprot)
6498 
    iprot.readMessageEnd()
6499 
    result = getItemStatusDescription_result()
6500 
    try:
6501 
      result.success = self._handler.getItemStatusDescription(args.itemId)
6502 
    except CatalogServiceException, isex:
6503 
      result.isex = isex
6504 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
6505 
    result.write(oprot)
6506 
    oprot.writeMessageEnd()
6507 
    oprot.trans.flush()
6508 
 
6509 
  def process_startItemOn(self, seqid, iprot, oprot):
6510 
    args = startItemOn_args()
6511 
    args.read(iprot)
6512 
    iprot.readMessageEnd()
6513 
    result = startItemOn_result()
6514 
    try:
6515 
      self._handler.startItemOn(args.item_id, args.timestamp)
6516 
    except CatalogServiceException, cex:
6517 
      result.cex = cex
6518 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
6519 
    result.write(oprot)
6520 
    oprot.writeMessageEnd()
6521 
    oprot.trans.flush()
6522 
 
6523 
  def process_retireItemOn(self, seqid, iprot, oprot):
6524 
    args = retireItemOn_args()
6525 
    args.read(iprot)
6526 
    iprot.readMessageEnd()
6527 
    result = retireItemOn_result()
6528 
    try:
6529 
      self._handler.retireItemOn(args.item_id, args.timestamp)
6530 
    except CatalogServiceException, cex:
6531 
      result.cex = cex
6532 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
6533 
    result.write(oprot)
6534 
    oprot.writeMessageEnd()
6535 
    oprot.trans.flush()
6536 
 
6537 
  def process_changeItemStatus(self, seqid, iprot, oprot):
6538 
    args = changeItemStatus_args()
6539 
    args.read(iprot)
6540 
    iprot.readMessageEnd()
6541 
    result = changeItemStatus_result()
6542 
    try:
6543 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
6544 
    except CatalogServiceException, cex:
6545 
      result.cex = cex
6546 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
6547 
    result.write(oprot)
6548 
    oprot.writeMessageEnd()
6549 
    oprot.trans.flush()
6550 
 
6551 
  def process_getItem(self, seqid, iprot, oprot):
6552 
    args = getItem_args()
6553 
    args.read(iprot)
6554 
    iprot.readMessageEnd()
6555 
    result = getItem_result()
6556 
    try:
6557 
      result.success = self._handler.getItem(args.item_id)
6558 
    except CatalogServiceException, cex:
6559 
      result.cex = cex
6560 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
6561 
    result.write(oprot)
6562 
    oprot.writeMessageEnd()
6563 
    oprot.trans.flush()
6564 
 
6565 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
6566 
    args = getItemsByCatalogId_args()
6567 
    args.read(iprot)
6568 
    iprot.readMessageEnd()
6569 
    result = getItemsByCatalogId_result()
6570 
    try:
6571 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
6572 
    except CatalogServiceException, cex:
6573 
      result.cex = cex
6574 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
6575 
    result.write(oprot)
6576 
    oprot.writeMessageEnd()
6577 
    oprot.trans.flush()
6578 
 
6579 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
6580 
    args = getValidItemsByCatalogId_args()
6581 
    args.read(iprot)
6582 
    iprot.readMessageEnd()
6583 
    result = getValidItemsByCatalogId_result()
6584 
    try:
6585 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
6586 
    except CatalogServiceException, cex:
6587 
      result.cex = cex
6588 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
6589 
    result.write(oprot)
6590 
    oprot.writeMessageEnd()
6591 
    oprot.trans.flush()
6592 
 
6593 
  def process_getAllItems(self, seqid, iprot, oprot):
6594 
    args = getAllItems_args()
6595 
    args.read(iprot)
6596 
    iprot.readMessageEnd()
6597 
    result = getAllItems_result()
6598 
    try:
6599 
      result.success = self._handler.getAllItems(args.isActive)
6600 
    except CatalogServiceException, cex:
6601 
      result.cex = cex
6602 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
6603 
    result.write(oprot)
6604 
    oprot.writeMessageEnd()
6605 
    oprot.trans.flush()
6606 
 
6607 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
6608 
    args = getAllItemsByStatus_args()
6609 
    args.read(iprot)
6610 
    iprot.readMessageEnd()
6611 
    result = getAllItemsByStatus_result()
6612 
    try:
6613 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
6614 
    except CatalogServiceException, cex:
6615 
      result.cex = cex
6616 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
6617 
    result.write(oprot)
6618 
    oprot.writeMessageEnd()
6619 
    oprot.trans.flush()
6620 
 
6621 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
6622 
    args = markItemAsContentComplete_args()
6623 
    args.read(iprot)
6624 
    iprot.readMessageEnd()
6625 
    result = markItemAsContentComplete_result()
6626 
    try:
9253 rajveer 6627 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 6628 
    except CatalogServiceException, cex:
6629 
      result.cex = cex
6630 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
6631 
    result.write(oprot)
6632 
    oprot.writeMessageEnd()
6633 
    oprot.trans.flush()
6634 
 
6635 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
6636 
    args = getAllItemsInRange_args()
6637 
    args.read(iprot)
6638 
    iprot.readMessageEnd()
6639 
    result = getAllItemsInRange_result()
6640 
    try:
6641 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
6642 
    except CatalogServiceException, cex:
6643 
      result.cex = cex
6644 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
6645 
    result.write(oprot)
6646 
    oprot.writeMessageEnd()
6647 
    oprot.trans.flush()
6648 
 
6649 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
6650 
    args = getAllItemsByStatusInRange_args()
6651 
    args.read(iprot)
6652 
    iprot.readMessageEnd()
6653 
    result = getAllItemsByStatusInRange_result()
6654 
    try:
6655 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
6656 
    except CatalogServiceException, cex:
6657 
      result.cex = cex
6658 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
6659 
    result.write(oprot)
6660 
    oprot.writeMessageEnd()
6661 
    oprot.trans.flush()
6662 
 
6663 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
6664 
    args = getItemCountByStatus_args()
6665 
    args.read(iprot)
6666 
    iprot.readMessageEnd()
6667 
    result = getItemCountByStatus_result()
6668 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
6669 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
6670 
    result.write(oprot)
6671 
    oprot.writeMessageEnd()
6672 
    oprot.trans.flush()
6673 
 
6674 
  def process_getBestSellers(self, seqid, iprot, oprot):
6675 
    args = getBestSellers_args()
6676 
    args.read(iprot)
6677 
    iprot.readMessageEnd()
6678 
    result = getBestSellers_result()
6679 
    try:
6680 
      result.success = self._handler.getBestSellers()
6681 
    except CatalogServiceException, isex:
6682 
      result.isex = isex
6683 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
6684 
    result.write(oprot)
6685 
    oprot.writeMessageEnd()
6686 
    oprot.trans.flush()
6687 
 
6688 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
6689 
    args = getBestSellersCatalogIds_args()
6690 
    args.read(iprot)
6691 
    iprot.readMessageEnd()
6692 
    result = getBestSellersCatalogIds_result()
6693 
    try:
6694 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6695 
    except CatalogServiceException, cex:
6696 
      result.cex = cex
6697 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
6698 
    result.write(oprot)
6699 
    oprot.writeMessageEnd()
6700 
    oprot.trans.flush()
6701 
 
6702 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
6703 
    args = getBestSellersCount_args()
6704 
    args.read(iprot)
6705 
    iprot.readMessageEnd()
6706 
    result = getBestSellersCount_result()
6707 
    try:
6708 
      result.success = self._handler.getBestSellersCount()
6709 
    except CatalogServiceException, cex:
6710 
      result.cex = cex
6711 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
6712 
    result.write(oprot)
6713 
    oprot.writeMessageEnd()
6714 
    oprot.trans.flush()
6715 
 
6716 
  def process_getBestDeals(self, seqid, iprot, oprot):
6717 
    args = getBestDeals_args()
6718 
    args.read(iprot)
6719 
    iprot.readMessageEnd()
6720 
    result = getBestDeals_result()
6721 
    try:
6722 
      result.success = self._handler.getBestDeals()
6723 
    except CatalogServiceException, isex:
6724 
      result.isex = isex
6725 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
6726 
    result.write(oprot)
6727 
    oprot.writeMessageEnd()
6728 
    oprot.trans.flush()
6729 
 
6730 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
6731 
    args = getBestDealsCatalogIds_args()
6732 
    args.read(iprot)
6733 
    iprot.readMessageEnd()
6734 
    result = getBestDealsCatalogIds_result()
6735 
    try:
6736 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6737 
    except CatalogServiceException, cex:
6738 
      result.cex = cex
6739 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
6740 
    result.write(oprot)
6741 
    oprot.writeMessageEnd()
6742 
    oprot.trans.flush()
6743 
 
6744 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
6745 
    args = getBestDealsCount_args()
6746 
    args.read(iprot)
6747 
    iprot.readMessageEnd()
6748 
    result = getBestDealsCount_result()
6749 
    try:
6750 
      result.success = self._handler.getBestDealsCount()
6751 
    except CatalogServiceException, cex:
6752 
      result.cex = cex
6753 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
6754 
    result.write(oprot)
6755 
    oprot.writeMessageEnd()
6756 
    oprot.trans.flush()
6757 
 
6758 
  def process_getComingSoon(self, seqid, iprot, oprot):
6759 
    args = getComingSoon_args()
6760 
    args.read(iprot)
6761 
    iprot.readMessageEnd()
6762 
    result = getComingSoon_result()
6763 
    try:
6764 
      result.success = self._handler.getComingSoon()
6765 
    except CatalogServiceException, isex:
6766 
      result.isex = isex
6767 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
6768 
    result.write(oprot)
6769 
    oprot.writeMessageEnd()
6770 
    oprot.trans.flush()
6771 
 
6772 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
6773 
    args = getComingSoonCatalogIds_args()
6774 
    args.read(iprot)
6775 
    iprot.readMessageEnd()
6776 
    result = getComingSoonCatalogIds_result()
6777 
    try:
6778 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6779 
    except CatalogServiceException, cex:
6780 
      result.cex = cex
6781 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
6782 
    result.write(oprot)
6783 
    oprot.writeMessageEnd()
6784 
    oprot.trans.flush()
6785 
 
6786 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
6787 
    args = getComingSoonCount_args()
6788 
    args.read(iprot)
6789 
    iprot.readMessageEnd()
6790 
    result = getComingSoonCount_result()
6791 
    try:
6792 
      result.success = self._handler.getComingSoonCount()
6793 
    except CatalogServiceException, cex:
6794 
      result.cex = cex
6795 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
6796 
    result.write(oprot)
6797 
    oprot.writeMessageEnd()
6798 
    oprot.trans.flush()
6799 
 
6800 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
6801 
    args = getLatestArrivals_args()
6802 
    args.read(iprot)
6803 
    iprot.readMessageEnd()
6804 
    result = getLatestArrivals_result()
6805 
    try:
6806 
      result.success = self._handler.getLatestArrivals()
6807 
    except CatalogServiceException, isex:
6808 
      result.isex = isex
6809 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
6810 
    result.write(oprot)
6811 
    oprot.writeMessageEnd()
6812 
    oprot.trans.flush()
6813 
 
6814 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
6815 
    args = getLatestArrivalsCatalogIds_args()
6816 
    args.read(iprot)
6817 
    iprot.readMessageEnd()
6818 
    result = getLatestArrivalsCatalogIds_result()
6819 
    try:
6820 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
6821 
    except CatalogServiceException, cex:
6822 
      result.cex = cex
6823 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
6824 
    result.write(oprot)
6825 
    oprot.writeMessageEnd()
6826 
    oprot.trans.flush()
6827 
 
6828 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
6829 
    args = getLatestArrivalsCount_args()
6830 
    args.read(iprot)
6831 
    iprot.readMessageEnd()
6832 
    result = getLatestArrivalsCount_result()
6833 
    try:
6834 
      result.success = self._handler.getLatestArrivalsCount()
6835 
    except CatalogServiceException, cex:
6836 
      result.cex = cex
6837 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
6838 
    result.write(oprot)
6839 
    oprot.writeMessageEnd()
6840 
    oprot.trans.flush()
6841 
 
6842 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
6843 
    args = generateNewEntityID_args()
6844 
    args.read(iprot)
6845 
    iprot.readMessageEnd()
6846 
    result = generateNewEntityID_result()
6847 
    result.success = self._handler.generateNewEntityID()
6848 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
6849 
    result.write(oprot)
6850 
    oprot.writeMessageEnd()
6851 
    oprot.trans.flush()
6852 
 
6853 
  def process_addCategory(self, seqid, iprot, oprot):
6854 
    args = addCategory_args()
6855 
    args.read(iprot)
6856 
    iprot.readMessageEnd()
6857 
    result = addCategory_result()
6858 
    result.success = self._handler.addCategory(args.category)
6859 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
6860 
    result.write(oprot)
6861 
    oprot.writeMessageEnd()
6862 
    oprot.trans.flush()
6863 
 
6864 
  def process_getCategory(self, seqid, iprot, oprot):
6865 
    args = getCategory_args()
6866 
    args.read(iprot)
6867 
    iprot.readMessageEnd()
6868 
    result = getCategory_result()
6869 
    result.success = self._handler.getCategory(args.id)
6870 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
6871 
    result.write(oprot)
6872 
    oprot.writeMessageEnd()
6873 
    oprot.trans.flush()
6874 
 
6875 
  def process_getAllCategories(self, seqid, iprot, oprot):
6876 
    args = getAllCategories_args()
6877 
    args.read(iprot)
6878 
    iprot.readMessageEnd()
6879 
    result = getAllCategories_result()
6880 
    result.success = self._handler.getAllCategories()
6881 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
6882 
    result.write(oprot)
6883 
    oprot.writeMessageEnd()
6884 
    oprot.trans.flush()
6885 
 
6886 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
6887 
    args = getAllSimilarItems_args()
6888 
    args.read(iprot)
6889 
    iprot.readMessageEnd()
6890 
    result = getAllSimilarItems_result()
6891 
    result.success = self._handler.getAllSimilarItems(args.itemId)
6892 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
6893 
    result.write(oprot)
6894 
    oprot.writeMessageEnd()
6895 
    oprot.trans.flush()
6896 
 
6897 
  def process_addSimilarItem(self, seqid, iprot, oprot):
6898 
    args = addSimilarItem_args()
6899 
    args.read(iprot)
6900 
    iprot.readMessageEnd()
6901 
    result = addSimilarItem_result()
6902 
    try:
6903 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
6904 
    except CatalogServiceException, cex:
6905 
      result.cex = cex
6906 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
6907 
    result.write(oprot)
6908 
    oprot.writeMessageEnd()
6909 
    oprot.trans.flush()
6910 
 
6512 kshitij.so 6911 
  def process_addTag(self, seqid, iprot, oprot):
6912 
    args = addTag_args()
6913 
    args.read(iprot)
6914 
    iprot.readMessageEnd()
6915 
    result = addTag_result()
6916 
    result.success = self._handler.addTag(args.displayName, args.itemId)
6917 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
6918 
    result.write(oprot)
6919 
    oprot.writeMessageEnd()
6920 
    oprot.trans.flush()
6921 
 
6922 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
6923 
    args = deleteEntityTag_args()
6924 
    args.read(iprot)
6925 
    iprot.readMessageEnd()
6926 
    result = deleteEntityTag_result()
6927 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
6928 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
6929 
    result.write(oprot)
6930 
    oprot.writeMessageEnd()
6931 
    oprot.trans.flush()
6932 
 
6933 
  def process_deleteTag(self, seqid, iprot, oprot):
6934 
    args = deleteTag_args()
6935 
    args.read(iprot)
6936 
    iprot.readMessageEnd()
6937 
    result = deleteTag_result()
6938 
    result.success = self._handler.deleteTag(args.displayName)
6939 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
6940 
    result.write(oprot)
6941 
    oprot.writeMessageEnd()
6942 
    oprot.trans.flush()
6943 
 
6944 
  def process_getAllTags(self, seqid, iprot, oprot):
6945 
    args = getAllTags_args()
6946 
    args.read(iprot)
6947 
    iprot.readMessageEnd()
6948 
    result = getAllTags_result()
6949 
    result.success = self._handler.getAllTags()
6950 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
6951 
    result.write(oprot)
6952 
    oprot.writeMessageEnd()
6953 
    oprot.trans.flush()
6954 
 
6955 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
6956 
    args = getAllEntitiesByTagName_args()
6957 
    args.read(iprot)
6958 
    iprot.readMessageEnd()
6959 
    result = getAllEntitiesByTagName_result()
6960 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
6961 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
6962 
    result.write(oprot)
6963 
    oprot.writeMessageEnd()
6964 
    oprot.trans.flush()
6965 
 
6845 amit.gupta 6966 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
6967 
    args = getAllEntityTags_args()
6968 
    args.read(iprot)
6969 
    iprot.readMessageEnd()
6970 
    result = getAllEntityTags_result()
6971 
    result.success = self._handler.getAllEntityTags()
6972 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
6973 
    result.write(oprot)
6974 
    oprot.writeMessageEnd()
6975 
    oprot.trans.flush()
6976 
 
6850 kshitij.so 6977 
  def process_addBanner(self, seqid, iprot, oprot):
6978 
    args = addBanner_args()
6979 
    args.read(iprot)
6980 
    iprot.readMessageEnd()
6981 
    result = addBanner_result()
10097 kshitij.so 6982 
    result.success = self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 6983 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
6984 
    result.write(oprot)
6985 
    oprot.writeMessageEnd()
6986 
    oprot.trans.flush()
6987 
 
8579 kshitij.so 6988 
  def process_updateBanner(self, seqid, iprot, oprot):
6989 
    args = updateBanner_args()
6990 
    args.read(iprot)
6991 
    iprot.readMessageEnd()
6992 
    result = updateBanner_result()
6993 
    result.success = self._handler.updateBanner(args.banner)
6994 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
6995 
    result.write(oprot)
6996 
    oprot.writeMessageEnd()
6997 
    oprot.trans.flush()
6998 
 
6850 kshitij.so 6999 
  def process_getAllBanners(self, seqid, iprot, oprot):
7000 
    args = getAllBanners_args()
7001 
    args.read(iprot)
7002 
    iprot.readMessageEnd()
7003 
    result = getAllBanners_result()
7004 
    result.success = self._handler.getAllBanners()
7005 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
7006 
    result.write(oprot)
7007 
    oprot.writeMessageEnd()
7008 
    oprot.trans.flush()
7009 
 
7010 
  def process_deleteBanner(self, seqid, iprot, oprot):
7011 
    args = deleteBanner_args()
7012 
    args.read(iprot)
7013 
    iprot.readMessageEnd()
7014 
    result = deleteBanner_result()
9155 kshitij.so 7015 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 7016 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
7017 
    result.write(oprot)
7018 
    oprot.writeMessageEnd()
7019 
    oprot.trans.flush()
7020 
 
7021 
  def process_getBannerDetails(self, seqid, iprot, oprot):
7022 
    args = getBannerDetails_args()
7023 
    args.read(iprot)
7024 
    iprot.readMessageEnd()
7025 
    result = getBannerDetails_result()
9155 kshitij.so 7026 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 7027 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
7028 
    result.write(oprot)
7029 
    oprot.writeMessageEnd()
7030 
    oprot.trans.flush()
7031 
 
7032 
  def process_getActiveBanners(self, seqid, iprot, oprot):
7033 
    args = getActiveBanners_args()
7034 
    args.read(iprot)
7035 
    iprot.readMessageEnd()
7036 
    result = getActiveBanners_result()
7037 
    result.success = self._handler.getActiveBanners()
7038 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
7039 
    result.write(oprot)
7040 
    oprot.writeMessageEnd()
7041 
    oprot.trans.flush()
7042 
 
6849 kshitij.so 7043 
  def process_addBannerMap(self, seqid, iprot, oprot):
7044 
    args = addBannerMap_args()
7045 
    args.read(iprot)
7046 
    iprot.readMessageEnd()
7047 
    result = addBannerMap_result()
8579 kshitij.so 7048 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 7049 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
7050 
    result.write(oprot)
7051 
    oprot.writeMessageEnd()
7052 
    oprot.trans.flush()
7053 
 
8579 kshitij.so 7054 
  def process_updateBannerMap(self, seqid, iprot, oprot):
7055 
    args = updateBannerMap_args()
7056 
    args.read(iprot)
7057 
    iprot.readMessageEnd()
7058 
    result = updateBannerMap_result()
7059 
    result.success = self._handler.updateBannerMap(args.bannerMap)
7060 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
7061 
    result.write(oprot)
7062 
    oprot.writeMessageEnd()
7063 
    oprot.trans.flush()
7064 
 
6849 kshitij.so 7065 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
7066 
    args = deleteBannerMap_args()
7067 
    args.read(iprot)
7068 
    iprot.readMessageEnd()
7069 
    result = deleteBannerMap_result()
7070 
    result.success = self._handler.deleteBannerMap(args.bannerName)
7071 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
7072 
    result.write(oprot)
7073 
    oprot.writeMessageEnd()
7074 
    oprot.trans.flush()
7075 
 
7076 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
7077 
    args = getBannerMapDetails_args()
7078 
    args.read(iprot)
7079 
    iprot.readMessageEnd()
7080 
    result = getBannerMapDetails_result()
9155 kshitij.so 7081 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 7082 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
7083 
    result.write(oprot)
7084 
    oprot.writeMessageEnd()
7085 
    oprot.trans.flush()
7086 
 
8579 kshitij.so 7087 
  def process_addBannerUri(self, seqid, iprot, oprot):
7088 
    args = addBannerUri_args()
7089 
    args.read(iprot)
7090 
    iprot.readMessageEnd()
7091 
    result = addBannerUri_result()
7092 
    self._handler.addBannerUri(args.bannerUriMappings)
7093 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
7094 
    result.write(oprot)
7095 
    oprot.writeMessageEnd()
7096 
    oprot.trans.flush()
7097 
 
7098 
  def process_getUriMapping(self, seqid, iprot, oprot):
7099 
    args = getUriMapping_args()
7100 
    args.read(iprot)
7101 
    iprot.readMessageEnd()
7102 
    result = getUriMapping_result()
9155 kshitij.so 7103 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 7104 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
7105 
    result.write(oprot)
7106 
    oprot.writeMessageEnd()
7107 
    oprot.trans.flush()
7108 
 
7109 
  def process_addCampaign(self, seqid, iprot, oprot):
7110 
    args = addCampaign_args()
7111 
    args.read(iprot)
7112 
    iprot.readMessageEnd()
7113 
    result = addCampaign_result()
7114 
    self._handler.addCampaign(args.campaign)
7115 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
7116 
    result.write(oprot)
7117 
    oprot.writeMessageEnd()
7118 
    oprot.trans.flush()
7119 
 
7120 
  def process_getCampaigns(self, seqid, iprot, oprot):
7121 
    args = getCampaigns_args()
7122 
    args.read(iprot)
7123 
    iprot.readMessageEnd()
7124 
    result = getCampaigns_result()
7125 
    result.success = self._handler.getCampaigns(args.campaignName)
7126 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
7127 
    result.write(oprot)
7128 
    oprot.writeMessageEnd()
7129 
    oprot.trans.flush()
7130 
 
7131 
  def process_deleteCampaign(self, seqid, iprot, oprot):
7132 
    args = deleteCampaign_args()
7133 
    args.read(iprot)
7134 
    iprot.readMessageEnd()
7135 
    result = deleteCampaign_result()
7136 
    self._handler.deleteCampaign(args.campaignId)
7137 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
7138 
    result.write(oprot)
7139 
    oprot.writeMessageEnd()
7140 
    oprot.trans.flush()
7141 
 
7142 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
7143 
    args = getAllCampaigns_args()
7144 
    args.read(iprot)
7145 
    iprot.readMessageEnd()
7146 
    result = getAllCampaigns_result()
7147 
    result.success = self._handler.getAllCampaigns()
7148 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
7149 
    result.write(oprot)
7150 
    oprot.writeMessageEnd()
7151 
    oprot.trans.flush()
7152 
 
9155 kshitij.so 7153 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
7154 
    args = getActiveBannersForMobileSite_args()
7155 
    args.read(iprot)
7156 
    iprot.readMessageEnd()
7157 
    result = getActiveBannersForMobileSite_result()
7158 
    result.success = self._handler.getActiveBannersForMobileSite()
7159 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
7160 
    result.write(oprot)
7161 
    oprot.writeMessageEnd()
7162 
    oprot.trans.flush()
7163 
 
5944 mandeep.dh 7164 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
7165 
    args = deleteSimilarItem_args()
7166 
    args.read(iprot)
7167 
    iprot.readMessageEnd()
7168 
    result = deleteSimilarItem_result()
7169 
    try:
7170 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
7171 
    except CatalogServiceException, cex:
7172 
      result.cex = cex
7173 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
7174 
    result.write(oprot)
7175 
    oprot.writeMessageEnd()
7176 
    oprot.trans.flush()
7177 
 
7178 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
7179 
    args = checkSimilarItem_args()
7180 
    args.read(iprot)
7181 
    iprot.readMessageEnd()
7182 
    result = checkSimilarItem_result()
7183 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
7184 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
7185 
    result.write(oprot)
7186 
    oprot.writeMessageEnd()
7187 
    oprot.trans.flush()
7188 
 
7189 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
7190 
    args = validateRiskyStatus_args()
7191 
    args.read(iprot)
7192 
    iprot.readMessageEnd()
7193 
    result = validateRiskyStatus_result()
7194 
    self._handler.validateRiskyStatus(args.itemId)
7195 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
7196 
    result.write(oprot)
7197 
    oprot.writeMessageEnd()
7198 
    oprot.trans.flush()
7199 
 
7200 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
7201 
    args = changeItemRiskyFlag_args()
7202 
    args.read(iprot)
7203 
    iprot.readMessageEnd()
7204 
    result = changeItemRiskyFlag_result()
7205 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
7206 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
7207 
    result.write(oprot)
7208 
    oprot.writeMessageEnd()
7209 
    oprot.trans.flush()
7210 
 
7211 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
7212 
    args = getItemsByRiskyFlag_args()
7213 
    args.read(iprot)
7214 
    iprot.readMessageEnd()
7215 
    result = getItemsByRiskyFlag_result()
7216 
    result.success = self._handler.getItemsByRiskyFlag()
7217 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
7218 
    result.write(oprot)
7219 
    oprot.writeMessageEnd()
7220 
    oprot.trans.flush()
7221 
 
7222 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
7223 
    args = getItemsForMasterSheet_args()
7224 
    args.read(iprot)
7225 
    iprot.readMessageEnd()
7226 
    result = getItemsForMasterSheet_result()
7227 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
7228 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
7229 
    result.write(oprot)
7230 
    oprot.writeMessageEnd()
7231 
    oprot.trans.flush()
7232 
 
7233 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
7234 
    args = getSimilarItemsCatalogIds_args()
7235 
    args.read(iprot)
7236 
    iprot.readMessageEnd()
7237 
    result = getSimilarItemsCatalogIds_result()
7238 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
7239 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
7240 
    result.write(oprot)
7241 
    oprot.writeMessageEnd()
7242 
    oprot.trans.flush()
7243 
 
7244 
  def process_addProductNotification(self, seqid, iprot, oprot):
7245 
    args = addProductNotification_args()
7246 
    args.read(iprot)
7247 
    iprot.readMessageEnd()
7248 
    result = addProductNotification_result()
7249 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
7250 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
7251 
    result.write(oprot)
7252 
    oprot.writeMessageEnd()
7253 
    oprot.trans.flush()
7254 
 
7255 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
7256 
    args = sendProductNotifications_args()
7257 
    args.read(iprot)
7258 
    iprot.readMessageEnd()
7259 
    result = sendProductNotifications_result()
7260 
    result.success = self._handler.sendProductNotifications()
7261 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
7262 
    result.write(oprot)
7263 
    oprot.writeMessageEnd()
7264 
    oprot.trans.flush()
7265 
 
7266 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
7267 
    args = getAllBrandsByCategory_args()
7268 
    args.read(iprot)
7269 
    iprot.readMessageEnd()
7270 
    result = getAllBrandsByCategory_result()
7271 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
7272 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
7273 
    result.write(oprot)
7274 
    oprot.writeMessageEnd()
7275 
    oprot.trans.flush()
7276 
 
7277 
  def process_getAllBrands(self, seqid, iprot, oprot):
7278 
    args = getAllBrands_args()
7279 
    args.read(iprot)
7280 
    iprot.readMessageEnd()
7281 
    result = getAllBrands_result()
7282 
    result.success = self._handler.getAllBrands()
7283 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
7284 
    result.write(oprot)
7285 
    oprot.writeMessageEnd()
7286 
    oprot.trans.flush()
7287 
 
7288 
  def process_getAllSources(self, seqid, iprot, oprot):
7289 
    args = getAllSources_args()
7290 
    args.read(iprot)
7291 
    iprot.readMessageEnd()
7292 
    result = getAllSources_result()
7293 
    result.success = self._handler.getAllSources()
7294 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
7295 
    result.write(oprot)
7296 
    oprot.writeMessageEnd()
7297 
    oprot.trans.flush()
7298 
 
7299 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
7300 
    args = getItemPricingBySource_args()
7301 
    args.read(iprot)
7302 
    iprot.readMessageEnd()
7303 
    result = getItemPricingBySource_result()
7304 
    try:
7305 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
7306 
    except CatalogServiceException, cex:
7307 
      result.cex = cex
7308 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
7309 
    result.write(oprot)
7310 
    oprot.writeMessageEnd()
7311 
    oprot.trans.flush()
7312 
 
7313 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
7314 
    args = addSourceItemPricing_args()
7315 
    args.read(iprot)
7316 
    iprot.readMessageEnd()
7317 
    result = addSourceItemPricing_result()
7318 
    try:
7319 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
7320 
    except CatalogServiceException, cex:
7321 
      result.cex = cex
7322 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
7323 
    result.write(oprot)
7324 
    oprot.writeMessageEnd()
7325 
    oprot.trans.flush()
7326 
 
7327 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
7328 
    args = getAllSourcePricing_args()
7329 
    args.read(iprot)
7330 
    iprot.readMessageEnd()
7331 
    result = getAllSourcePricing_result()
7332 
    try:
7333 
      result.success = self._handler.getAllSourcePricing(args.itemId)
7334 
    except CatalogServiceException, cex:
7335 
      result.cex = cex
7336 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
7337 
    result.write(oprot)
7338 
    oprot.writeMessageEnd()
7339 
    oprot.trans.flush()
7340 
 
7341 
  def process_getItemForSource(self, seqid, iprot, oprot):
7342 
    args = getItemForSource_args()
7343 
    args.read(iprot)
7344 
    iprot.readMessageEnd()
7345 
    result = getItemForSource_result()
7346 
    try:
7347 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
7348 
    except CatalogServiceException, cex:
7349 
      result.cex = cex
7350 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
7351 
    result.write(oprot)
7352 
    oprot.writeMessageEnd()
7353 
    oprot.trans.flush()
7354 
 
7355 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
7356 
    args = searchItemsInRange_args()
7357 
    args.read(iprot)
7358 
    iprot.readMessageEnd()
7359 
    result = searchItemsInRange_result()
7360 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
7361 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
7362 
    result.write(oprot)
7363 
    oprot.writeMessageEnd()
7364 
    oprot.trans.flush()
7365 
 
7366 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
7367 
    args = getSearchResultCount_args()
7368 
    args.read(iprot)
7369 
    iprot.readMessageEnd()
7370 
    result = getSearchResultCount_result()
7371 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
7372 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
7373 
    result.write(oprot)
7374 
    oprot.writeMessageEnd()
7375 
    oprot.trans.flush()
7376 
 
7377 
  def process_getProductNotifications(self, seqid, iprot, oprot):
7378 
    args = getProductNotifications_args()
7379 
    args.read(iprot)
7380 
    iprot.readMessageEnd()
7381 
    result = getProductNotifications_result()
7382 
    result.success = self._handler.getProductNotifications(args.startDateTime)
7383 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
7384 
    result.write(oprot)
7385 
    oprot.writeMessageEnd()
7386 
    oprot.trans.flush()
7387 
 
7388 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
7389 
    args = getProductNotificationRequestCount_args()
7390 
    args.read(iprot)
7391 
    iprot.readMessageEnd()
7392 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 7393 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 7394 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
7395 
    result.write(oprot)
7396 
    oprot.writeMessageEnd()
7397 
    oprot.trans.flush()
7398 
 
7399 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
7400 
    args = addAuthorizationLog_args()
7401 
    args.read(iprot)
7402 
    iprot.readMessageEnd()
7403 
    result = addAuthorizationLog_result()
7404 
    try:
7405 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
7406 
    except CatalogServiceException, cex:
7407 
      result.cex = cex
7408 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
7409 
    result.write(oprot)
7410 
    oprot.writeMessageEnd()
7411 
    oprot.trans.flush()
7412 
 
7413 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
7414 
    args = addupdateVoucherForItem_args()
7415 
    args.read(iprot)
7416 
    iprot.readMessageEnd()
7417 
    result = addupdateVoucherForItem_result()
7418 
    try:
7419 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
7420 
    except CatalogServiceException, cex:
7421 
      result.cex = cex
7422 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
7423 
    result.write(oprot)
7424 
    oprot.writeMessageEnd()
7425 
    oprot.trans.flush()
7426 
 
7427 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
7428 
    args = deleteVoucherForItem_args()
7429 
    args.read(iprot)
7430 
    iprot.readMessageEnd()
7431 
    result = deleteVoucherForItem_result()
7432 
    try:
7433 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
7434 
    except CatalogServiceException, cex:
7435 
      result.cex = cex
7436 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
7437 
    result.write(oprot)
7438 
    oprot.writeMessageEnd()
7439 
    oprot.trans.flush()
7440 
 
7441 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
7442 
    args = getVoucherAmount_args()
7443 
    args.read(iprot)
7444 
    iprot.readMessageEnd()
7445 
    result = getVoucherAmount_result()
7446 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
7447 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
7448 
    result.write(oprot)
7449 
    oprot.writeMessageEnd()
7450 
    oprot.trans.flush()
7451 
 
7452 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
7453 
    args = getAllItemVouchers_args()
7454 
    args.read(iprot)
7455 
    iprot.readMessageEnd()
7456 
    result = getAllItemVouchers_result()
7457 
    result.success = self._handler.getAllItemVouchers(args.itemId)
7458 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
7459 
    result.write(oprot)
7460 
    oprot.writeMessageEnd()
7461 
    oprot.trans.flush()
7462 
 
7463 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
7464 
    args = isValidCatalogItemId_args()
7465 
    args.read(iprot)
7466 
    iprot.readMessageEnd()
7467 
    result = isValidCatalogItemId_result()
7468 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
7469 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
7470 
    result.write(oprot)
7471 
    oprot.writeMessageEnd()
7472 
    oprot.trans.flush()
7473 
 
6039 amit.gupta 7474 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
7475 
    args = getVatPercentageForItem_args()
7476 
    args.read(iprot)
7477 
    iprot.readMessageEnd()
7478 
    result = getVatPercentageForItem_result()
7340 amit.gupta 7479 
    try:
7480 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
7481 
    except CatalogServiceException, cex:
7482 
      result.cex = cex
6039 amit.gupta 7483 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
7484 
    result.write(oprot)
7485 
    oprot.writeMessageEnd()
7486 
    oprot.trans.flush()
5944 mandeep.dh 7487 
 
6039 amit.gupta 7488 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
7489 
    args = getVatAmountForItem_args()
7490 
    args.read(iprot)
7491 
    iprot.readMessageEnd()
7492 
    result = getVatAmountForItem_result()
7493 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
7494 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
7495 
    result.write(oprot)
7496 
    oprot.writeMessageEnd()
7497 
    oprot.trans.flush()
7498 
 
6531 vikram.rag 7499 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
7500 
    args = getAllIgnoredInventoryUpdateItemsList_args()
7501 
    args.read(iprot)
7502 
    iprot.readMessageEnd()
7503 
    result = getAllIgnoredInventoryUpdateItemsList_result()
7504 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
7505 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
7506 
    result.write(oprot)
7507 
    oprot.writeMessageEnd()
7508 
    oprot.trans.flush()
6039 amit.gupta 7509 
 
6821 amar.kumar 7510 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
7511 
    args = getAllAliveItems_args()
7512 
    args.read(iprot)
7513 
    iprot.readMessageEnd()
7514 
    result = getAllAliveItems_result()
7515 
    result.success = self._handler.getAllAliveItems()
7516 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
7517 
    result.write(oprot)
7518 
    oprot.writeMessageEnd()
7519 
    oprot.trans.flush()
7520 
 
6805 anupam.sin 7521 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
7522 
    args = getInsuranceAmount_args()
7523 
    args.read(iprot)
7524 
    iprot.readMessageEnd()
7525 
    result = getInsuranceAmount_result()
6921 anupam.sin 7526 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 7527 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
7528 
    result.write(oprot)
7529 
    oprot.writeMessageEnd()
7530 
    oprot.trans.flush()
6531 vikram.rag 7531 
 
6805 anupam.sin 7532 
  def process_getInsurer(self, seqid, iprot, oprot):
7533 
    args = getInsurer_args()
7534 
    args.read(iprot)
7535 
    iprot.readMessageEnd()
7536 
    result = getInsurer_result()
7537 
    result.success = self._handler.getInsurer(args.insurerId)
7538 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
7539 
    result.write(oprot)
7540 
    oprot.writeMessageEnd()
7541 
    oprot.trans.flush()
7542 
 
6838 vikram.rag 7543 
  def process_getAllInsurers(self, seqid, iprot, oprot):
7544 
    args = getAllInsurers_args()
7545 
    args.read(iprot)
7546 
    iprot.readMessageEnd()
7547 
    result = getAllInsurers_result()
7548 
    result.success = self._handler.getAllInsurers()
7549 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
7550 
    result.write(oprot)
7551 
    oprot.writeMessageEnd()
7552 
    oprot.trans.flush()
6805 anupam.sin 7553 
 
6962 rajveer 7554 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
7555 
    args = updateInsuranceDeclaredAmount_args()
7556 
    args.read(iprot)
7557 
    iprot.readMessageEnd()
7558 
    result = updateInsuranceDeclaredAmount_result()
7559 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
7560 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
7561 
    result.write(oprot)
7562 
    oprot.writeMessageEnd()
7563 
    oprot.trans.flush()
6838 vikram.rag 7564 
 
7190 amar.kumar 7565 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
7566 
    args = getFreebieForItem_args()
7567 
    args.read(iprot)
7568 
    iprot.readMessageEnd()
7569 
    result = getFreebieForItem_result()
7570 
    result.success = self._handler.getFreebieForItem(args.itemId)
7571 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
7572 
    result.write(oprot)
7573 
    oprot.writeMessageEnd()
7574 
    oprot.trans.flush()
6962 rajveer 7575 
 
7190 amar.kumar 7576 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
7577 
    args = addOrUpdateFreebieForItem_args()
7578 
    args.read(iprot)
7579 
    iprot.readMessageEnd()
7580 
    result = addOrUpdateFreebieForItem_result()
7581 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
7582 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
7583 
    result.write(oprot)
7584 
    oprot.writeMessageEnd()
7585 
    oprot.trans.flush()
7586 
 
7272 amit.gupta 7587 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
7588 
    args = addOrUpdateBrandInfo_args()
7589 
    args.read(iprot)
7590 
    iprot.readMessageEnd()
7591 
    result = addOrUpdateBrandInfo_result()
7592 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
7593 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
7594 
    result.write(oprot)
7595 
    oprot.writeMessageEnd()
7596 
    oprot.trans.flush()
7597 
 
7598 
  def process_getBrandInfo(self, seqid, iprot, oprot):
7599 
    args = getBrandInfo_args()
7600 
    args.read(iprot)
7601 
    iprot.readMessageEnd()
7602 
    result = getBrandInfo_result()
7603 
    result.success = self._handler.getBrandInfo()
7604 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
7605 
    result.write(oprot)
7606 
    oprot.writeMessageEnd()
7607 
    oprot.trans.flush()
7608 
 
7256 rajveer 7609 
  def process_getStorePricing(self, seqid, iprot, oprot):
7610 
    args = getStorePricing_args()
7611 
    args.read(iprot)
7612 
    iprot.readMessageEnd()
7613 
    result = getStorePricing_result()
7614 
    result.success = self._handler.getStorePricing(args.itemId)
7615 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
7616 
    result.write(oprot)
7617 
    oprot.writeMessageEnd()
7618 
    oprot.trans.flush()
7190 amar.kumar 7619 
 
7306 rajveer 7620 
  def process_getStorePricings(self, seqid, iprot, oprot):
7621 
    args = getStorePricings_args()
7622 
    args.read(iprot)
7623 
    iprot.readMessageEnd()
7624 
    result = getStorePricings_result()
7625 
    result.success = self._handler.getStorePricings(args.itemIds)
7626 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
7627 
    result.write(oprot)
7628 
    oprot.writeMessageEnd()
7629 
    oprot.trans.flush()
7630 
 
7265 rajveer 7631 
  def process_updateStorePricing(self, seqid, iprot, oprot):
7632 
    args = updateStorePricing_args()
7633 
    args.read(iprot)
7634 
    iprot.readMessageEnd()
7635 
    result = updateStorePricing_result()
7382 rajveer 7636 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 7637 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
7638 
    result.write(oprot)
7639 
    oprot.writeMessageEnd()
7640 
    oprot.trans.flush()
7256 rajveer 7641 
 
7281 kshitij.so 7642 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
7643 
    args = getAllAmazonListedItems_args()
7644 
    args.read(iprot)
7645 
    iprot.readMessageEnd()
7646 
    result = getAllAmazonListedItems_result()
7647 
    result.success = self._handler.getAllAmazonListedItems()
7648 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
7649 
    result.write(oprot)
7650 
    oprot.writeMessageEnd()
7651 
    oprot.trans.flush()
7265 rajveer 7652 
 
8619 kshitij.so 7653 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
7654 
    args = searchAmazonItems_args()
7655 
    args.read(iprot)
7656 
    iprot.readMessageEnd()
7657 
    result = searchAmazonItems_result()
7658 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
7659 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
7660 
    result.write(oprot)
7661 
    oprot.writeMessageEnd()
7662 
    oprot.trans.flush()
7663 
 
7664 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
7665 
    args = getAmazonSearchResultCount_args()
7666 
    args.read(iprot)
7667 
    iprot.readMessageEnd()
7668 
    result = getAmazonSearchResultCount_result()
7669 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
7670 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
7671 
    result.write(oprot)
7672 
    oprot.writeMessageEnd()
7673 
    oprot.trans.flush()
7674 
 
7675 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
7676 
    args = getCountForAmazonlistedItems_args()
7677 
    args.read(iprot)
7678 
    iprot.readMessageEnd()
7679 
    result = getCountForAmazonlistedItems_result()
7680 
    result.success = self._handler.getCountForAmazonlistedItems()
7681 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
7682 
    result.write(oprot)
7683 
    oprot.writeMessageEnd()
7684 
    oprot.trans.flush()
7685 
 
7281 kshitij.so 7686 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
7687 
    args = getAmazonItemDetails_args()
7688 
    args.read(iprot)
7689 
    iprot.readMessageEnd()
7690 
    result = getAmazonItemDetails_result()
7691 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
7692 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
7693 
    result.write(oprot)
7694 
    oprot.writeMessageEnd()
7695 
    oprot.trans.flush()
7696 
 
7697 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
7698 
    args = updateAmazonItemDetails_args()
7699 
    args.read(iprot)
7700 
    iprot.readMessageEnd()
7701 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 7702 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 7703 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
7704 
    result.write(oprot)
7705 
    oprot.writeMessageEnd()
7706 
    oprot.trans.flush()
7707 
 
7708 
  def process_addAmazonItem(self, seqid, iprot, oprot):
7709 
    args = addAmazonItem_args()
7710 
    args.read(iprot)
7711 
    iprot.readMessageEnd()
7712 
    result = addAmazonItem_result()
7713 
    self._handler.addAmazonItem(args.amazonlisted)
7714 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
7715 
    result.write(oprot)
7716 
    oprot.writeMessageEnd()
7717 
    oprot.trans.flush()
7718 
 
7291 vikram.rag 7719 
  def process_getAsinItems(self, seqid, iprot, oprot):
7720 
    args = getAsinItems_args()
7721 
    args.read(iprot)
7722 
    iprot.readMessageEnd()
7723 
    result = getAsinItems_result()
7724 
    result.success = self._handler.getAsinItems()
7725 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
7726 
    result.write(oprot)
7727 
    oprot.writeMessageEnd()
7728 
    oprot.trans.flush()
7281 kshitij.so 7729 
 
7291 vikram.rag 7730 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
7731 
    args = getAllFbaListedItems_args()
7732 
    args.read(iprot)
7733 
    iprot.readMessageEnd()
7734 
    result = getAllFbaListedItems_result()
7735 
    result.success = self._handler.getAllFbaListedItems()
7736 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
7737 
    result.write(oprot)
7738 
    oprot.writeMessageEnd()
7739 
    oprot.trans.flush()
7740 
 
7741 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
7742 
    args = getAllNonFbaListedItems_args()
7743 
    args.read(iprot)
7744 
    iprot.readMessageEnd()
7745 
    result = getAllNonFbaListedItems_result()
7746 
    result.success = self._handler.getAllNonFbaListedItems()
7747 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
7748 
    result.write(oprot)
7749 
    oprot.writeMessageEnd()
7750 
    oprot.trans.flush()
7751 
 
7460 kshitij.so 7752 
  def process_updateItemInventory(self, seqid, iprot, oprot):
7753 
    args = updateItemInventory_args()
7754 
    args.read(iprot)
7755 
    iprot.readMessageEnd()
7756 
    result = updateItemInventory_result()
7757 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
7758 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
7759 
    result.write(oprot)
7760 
    oprot.writeMessageEnd()
7761 
    oprot.trans.flush()
7291 vikram.rag 7762 
 
7770 kshitij.so 7763 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
7764 
    args = updateTimestampForAmazonFeeds_args()
7765 
    args.read(iprot)
7766 
    iprot.readMessageEnd()
7767 
    result = updateTimestampForAmazonFeeds_result()
7768 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
7769 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
7770 
    result.write(oprot)
7771 
    oprot.writeMessageEnd()
7772 
    oprot.trans.flush()
7460 kshitij.so 7773 
 
7897 amar.kumar 7774 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
7775 
    args = getAllParentCategories_args()
7776 
    args.read(iprot)
7777 
    iprot.readMessageEnd()
7778 
    result = getAllParentCategories_result()
7779 
    result.success = self._handler.getAllParentCategories()
7780 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
7781 
    result.write(oprot)
7782 
    oprot.writeMessageEnd()
7783 
    oprot.trans.flush()
7770 kshitij.so 7784 
 
7977 kshitij.so 7785 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
7786 
    args = addPageViewEvent_args()
7787 
    args.read(iprot)
7788 
    iprot.readMessageEnd()
7789 
    result = addPageViewEvent_result()
7790 
    self._handler.addPageViewEvent(args.pageViewEvents)
7791 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
7792 
    result.write(oprot)
7793 
    oprot.writeMessageEnd()
7794 
    oprot.trans.flush()
7897 amar.kumar 7795 
 
7977 kshitij.so 7796 
  def process_addCartEvent(self, seqid, iprot, oprot):
7797 
    args = addCartEvent_args()
7798 
    args.read(iprot)
7799 
    iprot.readMessageEnd()
7800 
    result = addCartEvent_result()
7801 
    self._handler.addCartEvent(args.cartEvents)
7802 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
7803 
    result.write(oprot)
7804 
    oprot.writeMessageEnd()
7805 
    oprot.trans.flush()
7806 
 
8182 amar.kumar 7807 
  def process_addEbayItem(self, seqid, iprot, oprot):
7808 
    args = addEbayItem_args()
7809 
    args.read(iprot)
7810 
    iprot.readMessageEnd()
7811 
    result = addEbayItem_result()
7812 
    self._handler.addEbayItem(args.ebayItem)
7813 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
7814 
    result.write(oprot)
7815 
    oprot.writeMessageEnd()
7816 
    oprot.trans.flush()
7817 
 
7818 
  def process_getEbayItem(self, seqid, iprot, oprot):
7819 
    args = getEbayItem_args()
7820 
    args.read(iprot)
7821 
    iprot.readMessageEnd()
7822 
    result = getEbayItem_result()
7823 
    result.success = self._handler.getEbayItem(args.listingId)
7824 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
7825 
    result.write(oprot)
7826 
    oprot.writeMessageEnd()
7827 
    oprot.trans.flush()
7828 
 
7829 
  def process_updateEbayItem(self, seqid, iprot, oprot):
7830 
    args = updateEbayItem_args()
7831 
    args.read(iprot)
7832 
    iprot.readMessageEnd()
7833 
    result = updateEbayItem_result()
7834 
    self._handler.updateEbayItem(args.ebayItem)
7835 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
7836 
    result.write(oprot)
7837 
    oprot.writeMessageEnd()
7838 
    oprot.trans.flush()
7839 
 
8139 kshitij.so 7840 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
7841 
    args = getAmazonListedItems_args()
7842 
    args.read(iprot)
7843 
    iprot.readMessageEnd()
7844 
    result = getAmazonListedItems_result()
7845 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
7846 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
7847 
    result.write(oprot)
7848 
    oprot.writeMessageEnd()
7849 
    oprot.trans.flush()
7977 kshitij.so 7850 
 
8168 kshitij.so 7851 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
7852 
    args = updateAmazonAttributesInBulk_args()
7853 
    args.read(iprot)
7854 
    iprot.readMessageEnd()
7855 
    result = updateAmazonAttributesInBulk_result()
7856 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
7857 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
7858 
    result.write(oprot)
7859 
    oprot.writeMessageEnd()
7860 
    oprot.trans.flush()
8139 kshitij.so 7861 
 
8379 vikram.rag 7862 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
7863 
    args = getAllItemstoListOnFba_args()
7864 
    args.read(iprot)
7865 
    iprot.readMessageEnd()
7866 
    result = getAllItemstoListOnFba_result()
7867 
    result.success = self._handler.getAllItemstoListOnFba()
7868 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
7869 
    result.write(oprot)
7870 
    oprot.writeMessageEnd()
7871 
    oprot.trans.flush()
8168 kshitij.so 7872 
 
8379 vikram.rag 7873 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
7874 
    args = getAllItemstoListOnNonFba_args()
7875 
    args.read(iprot)
7876 
    iprot.readMessageEnd()
7877 
    result = getAllItemstoListOnNonFba_result()
7878 
    result.success = self._handler.getAllItemstoListOnNonFba()
7879 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
7880 
    result.write(oprot)
7881 
    oprot.writeMessageEnd()
7882 
    oprot.trans.flush()
7883 
 
8619 kshitij.so 7884 
  def process_updateAsin(self, seqid, iprot, oprot):
7885 
    args = updateAsin_args()
7886 
    args.read(iprot)
7887 
    iprot.readMessageEnd()
7888 
    result = updateAsin_result()
7889 
    self._handler.updateAsin(args.item)
7890 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
7891 
    result.write(oprot)
7892 
    oprot.writeMessageEnd()
7893 
    oprot.trans.flush()
8616 vikram.rag 7894 
 
8739 vikram.rag 7895 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
7896 
    args = addOrUpdateSnapdealItem_args()
7897 
    args.read(iprot)
7898 
    iprot.readMessageEnd()
7899 
    result = addOrUpdateSnapdealItem_result()
7900 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
7901 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
7902 
    result.write(oprot)
7903 
    oprot.writeMessageEnd()
7904 
    oprot.trans.flush()
8619 kshitij.so 7905 
 
8739 vikram.rag 7906 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
7907 
    args = getSnapdealItem_args()
7908 
    args.read(iprot)
7909 
    iprot.readMessageEnd()
7910 
    result = getSnapdealItem_result()
7911 
    result.success = self._handler.getSnapdealItem(args.item_id)
7912 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
7913 
    result.write(oprot)
7914 
    oprot.writeMessageEnd()
7915 
    oprot.trans.flush()
7916 
 
9242 kshitij.so 7917 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
7918 
    args = getSnapdealItemDetails_args()
7919 
    args.read(iprot)
7920 
    iprot.readMessageEnd()
7921 
    result = getSnapdealItemDetails_result()
7922 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
7923 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
7924 
    result.write(oprot)
7925 
    oprot.writeMessageEnd()
7926 
    oprot.trans.flush()
7927 
 
8739 vikram.rag 7928 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
7929 
    args = getAllSnapdealItems_args()
7930 
    args.read(iprot)
7931 
    iprot.readMessageEnd()
7932 
    result = getAllSnapdealItems_result()
7933 
    result.success = self._handler.getAllSnapdealItems()
7934 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
7935 
    result.write(oprot)
7936 
    oprot.writeMessageEnd()
7937 
    oprot.trans.flush()
7938 
 
9242 kshitij.so 7939 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
7940 
    args = getSnapdealItems_args()
7941 
    args.read(iprot)
7942 
    iprot.readMessageEnd()
7943 
    result = getSnapdealItems_result()
7944 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
7945 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
7946 
    result.write(oprot)
7947 
    oprot.writeMessageEnd()
7948 
    oprot.trans.flush()
8739 vikram.rag 7949 
 
9242 kshitij.so 7950 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
7951 
    args = searchSnapdealItems_args()
7952 
    args.read(iprot)
7953 
    iprot.readMessageEnd()
7954 
    result = searchSnapdealItems_result()
7955 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
7956 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
7957 
    result.write(oprot)
7958 
    oprot.writeMessageEnd()
7959 
    oprot.trans.flush()
7960 
 
7961 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
7962 
    args = getCountForSnapdealItems_args()
7963 
    args.read(iprot)
7964 
    iprot.readMessageEnd()
7965 
    result = getCountForSnapdealItems_result()
7966 
    result.success = self._handler.getCountForSnapdealItems()
7967 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
7968 
    result.write(oprot)
7969 
    oprot.writeMessageEnd()
7970 
    oprot.trans.flush()
7971 
 
7972 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
7973 
    args = getSnapdealSearchResultCount_args()
7974 
    args.read(iprot)
7975 
    iprot.readMessageEnd()
7976 
    result = getSnapdealSearchResultCount_result()
7977 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
7978 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
7979 
    result.write(oprot)
7980 
    oprot.writeMessageEnd()
7981 
    oprot.trans.flush()
7982 
 
9299 kshitij.so 7983 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
7984 
    args = getPrefferedInsurerForItem_args()
7985 
    args.read(iprot)
7986 
    iprot.readMessageEnd()
7987 
    result = getPrefferedInsurerForItem_result()
7988 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
7989 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
7990 
    result.write(oprot)
7991 
    oprot.writeMessageEnd()
7992 
    oprot.trans.flush()
9242 kshitij.so 7993 
 
9456 vikram.rag 7994 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
7995 
    args = getSnapdealItembySkuAtSnapdeal_args()
7996 
    args.read(iprot)
7997 
    iprot.readMessageEnd()
7998 
    result = getSnapdealItembySkuAtSnapdeal_result()
7999 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
8000 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
8001 
    result.write(oprot)
8002 
    oprot.writeMessageEnd()
8003 
    oprot.trans.flush()
9299 kshitij.so 8004 
 
9621 manish.sha 8005 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
8006 
    args = getProductFeedSubmit_args()
8007 
    args.read(iprot)
8008 
    iprot.readMessageEnd()
8009 
    result = getProductFeedSubmit_result()
8010 
    try:
8011 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
8012 
    except CatalogServiceException, cex:
8013 
      result.cex = cex
8014 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
8015 
    result.write(oprot)
8016 
    oprot.writeMessageEnd()
8017 
    oprot.trans.flush()
9456 vikram.rag 8018 
 
9621 manish.sha 8019 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
8020 
    args = addProductFeedSubmit_args()
8021 
    args.read(iprot)
8022 
    iprot.readMessageEnd()
8023 
    result = addProductFeedSubmit_result()
8024 
    try:
8025 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
8026 
    except CatalogServiceException, cex:
8027 
      result.cex = cex
8028 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
8029 
    result.write(oprot)
8030 
    oprot.writeMessageEnd()
8031 
    oprot.trans.flush()
8032 
 
8033 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
8034 
    args = updateProductFeedSubmit_args()
8035 
    args.read(iprot)
8036 
    iprot.readMessageEnd()
8037 
    result = updateProductFeedSubmit_result()
8038 
    try:
8039 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
8040 
    except CatalogServiceException, cex:
8041 
      result.cex = cex
8042 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
8043 
    result.write(oprot)
8044 
    oprot.writeMessageEnd()
8045 
    oprot.trans.flush()
8046 
 
8047 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
8048 
    args = deleteProductFeedSubmit_args()
8049 
    args.read(iprot)
8050 
    iprot.readMessageEnd()
8051 
    result = deleteProductFeedSubmit_result()
8052 
    try:
8053 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
8054 
    except CatalogServiceException, cex:
8055 
      result.cex = cex
8056 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
8057 
    result.write(oprot)
8058 
    oprot.writeMessageEnd()
8059 
    oprot.trans.flush()
8060 
 
8061 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
8062 
    args = getAllProductFeedSubmit_args()
8063 
    args.read(iprot)
8064 
    iprot.readMessageEnd()
8065 
    result = getAllProductFeedSubmit_result()
8066 
    try:
8067 
      result.success = self._handler.getAllProductFeedSubmit()
8068 
    except CatalogServiceException, cex:
8069 
      result.cex = cex
8070 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
8071 
    result.write(oprot)
8072 
    oprot.writeMessageEnd()
8073 
    oprot.trans.flush()
8074 
 
9724 kshitij.so 8075 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
8076 
    args = getMarketplacedetailsForItem_args()
8077 
    args.read(iprot)
8078 
    iprot.readMessageEnd()
8079 
    result = getMarketplacedetailsForItem_result()
8080 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
8081 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
8082 
    result.write(oprot)
8083 
    oprot.writeMessageEnd()
8084 
    oprot.trans.flush()
9621 manish.sha 8085 
 
9724 kshitij.so 8086 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
8087 
    args = updateMarketplaceAttributesForItem_args()
8088 
    args.read(iprot)
8089 
    iprot.readMessageEnd()
8090 
    result = updateMarketplaceAttributesForItem_result()
8091 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
8092 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
8093 
    result.write(oprot)
8094 
    oprot.writeMessageEnd()
8095 
    oprot.trans.flush()
8096 
 
9779 kshitij.so 8097 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
8098 
    args = getCostingForMarketplace_args()
8099 
    args.read(iprot)
8100 
    iprot.readMessageEnd()
8101 
    result = getCostingForMarketplace_result()
8102 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
8103 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
8104 
    result.write(oprot)
8105 
    oprot.writeMessageEnd()
8106 
    oprot.trans.flush()
8107 
 
9776 vikram.rag 8108 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
8109 
    args = getMarketPlaceItemsForPriceUpdate_args()
8110 
    args.read(iprot)
8111 
    iprot.readMessageEnd()
8112 
    result = getMarketPlaceItemsForPriceUpdate_result()
8113 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
8114 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
8115 
    result.write(oprot)
8116 
    oprot.writeMessageEnd()
8117 
    oprot.trans.flush()
9724 kshitij.so 8118 
 
9776 vikram.rag 8119 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
8120 
    args = updateMarketPlacePriceUpdateStatus_args()
8121 
    args.read(iprot)
8122 
    iprot.readMessageEnd()
8123 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 8124 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 8125 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
8126 
    result.write(oprot)
8127 
    oprot.writeMessageEnd()
8128 
    oprot.trans.flush()
8129 
 
9861 rajveer 8130 
  def process_updateItemHoldInventory(self, seqid, iprot, oprot):
8131 
    args = updateItemHoldInventory_args()
8132 
    args.read(iprot)
8133 
    iprot.readMessageEnd()
8134 
    result = updateItemHoldInventory_result()
8135 
    self._handler.updateItemHoldInventory(args.itemHoldMap)
8136 
    oprot.writeMessageBegin("updateItemHoldInventory", TMessageType.REPLY, seqid)
8137 
    result.write(oprot)
8138 
    oprot.writeMessageEnd()
8139 
    oprot.trans.flush()
9776 vikram.rag 8140 
 
9895 vikram.rag 8141 
  def process_updateNlcAtMarketplaces(self, seqid, iprot, oprot):
8142 
    args = updateNlcAtMarketplaces_args()
8143 
    args.read(iprot)
8144 
    iprot.readMessageEnd()
8145 
    result = updateNlcAtMarketplaces_result()
8146 
    self._handler.updateNlcAtMarketplaces(args.item_id, args.vendor_id, args.nlc)
8147 
    oprot.writeMessageBegin("updateNlcAtMarketplaces", TMessageType.REPLY, seqid)
8148 
    result.write(oprot)
8149 
    oprot.writeMessageEnd()
8150 
    oprot.trans.flush()
9861 rajveer 8151 
 
9945 vikram.rag 8152 
  def process_getAllFlipkartItems(self, seqid, iprot, oprot):
8153 
    args = getAllFlipkartItems_args()
8154 
    args.read(iprot)
8155 
    iprot.readMessageEnd()
8156 
    result = getAllFlipkartItems_result()
8157 
    result.success = self._handler.getAllFlipkartItems()
8158 
    oprot.writeMessageBegin("getAllFlipkartItems", TMessageType.REPLY, seqid)
8159 
    result.write(oprot)
8160 
    oprot.writeMessageEnd()
8161 
    oprot.trans.flush()
9895 vikram.rag 8162 
 
10097 kshitij.so 8163 
  def process_addOrUpdateFlipkartItem(self, seqid, iprot, oprot):
8164 
    args = addOrUpdateFlipkartItem_args()
8165 
    args.read(iprot)
8166 
    iprot.readMessageEnd()
8167 
    result = addOrUpdateFlipkartItem_result()
8168 
    result.success = self._handler.addOrUpdateFlipkartItem(args.flipkartitem)
8169 
    oprot.writeMessageBegin("addOrUpdateFlipkartItem", TMessageType.REPLY, seqid)
8170 
    result.write(oprot)
8171 
    oprot.writeMessageEnd()
8172 
    oprot.trans.flush()
9945 vikram.rag 8173 
 
10097 kshitij.so 8174 
  def process_getFlipkartItem(self, seqid, iprot, oprot):
8175 
    args = getFlipkartItem_args()
8176 
    args.read(iprot)
8177 
    iprot.readMessageEnd()
8178 
    result = getFlipkartItem_result()
8179 
    result.success = self._handler.getFlipkartItem(args.item_id)
8180 
    oprot.writeMessageBegin("getFlipkartItem", TMessageType.REPLY, seqid)
8181 
    result.write(oprot)
8182 
    oprot.writeMessageEnd()
8183 
    oprot.trans.flush()
8184 
 
8185 
  def process_getFlipkartItemDetails(self, seqid, iprot, oprot):
8186 
    args = getFlipkartItemDetails_args()
8187 
    args.read(iprot)
8188 
    iprot.readMessageEnd()
8189 
    result = getFlipkartItemDetails_result()
8190 
    result.success = self._handler.getFlipkartItemDetails(args.item_id)
8191 
    oprot.writeMessageBegin("getFlipkartItemDetails", TMessageType.REPLY, seqid)
8192 
    result.write(oprot)
8193 
    oprot.writeMessageEnd()
8194 
    oprot.trans.flush()
8195 
 
8196 
  def process_getFlipkartItems(self, seqid, iprot, oprot):
8197 
    args = getFlipkartItems_args()
8198 
    args.read(iprot)
8199 
    iprot.readMessageEnd()
8200 
    result = getFlipkartItems_result()
8201 
    result.success = self._handler.getFlipkartItems(args.offset, args.limit)
8202 
    oprot.writeMessageBegin("getFlipkartItems", TMessageType.REPLY, seqid)
8203 
    result.write(oprot)
8204 
    oprot.writeMessageEnd()
8205 
    oprot.trans.flush()
8206 
 
8207 
  def process_searchFlipkartItems(self, seqid, iprot, oprot):
8208 
    args = searchFlipkartItems_args()
8209 
    args.read(iprot)
8210 
    iprot.readMessageEnd()
8211 
    result = searchFlipkartItems_result()
8212 
    result.success = self._handler.searchFlipkartItems(args.searchTerm, args.offset, args.limit)
8213 
    oprot.writeMessageBegin("searchFlipkartItems", TMessageType.REPLY, seqid)
8214 
    result.write(oprot)
8215 
    oprot.writeMessageEnd()
8216 
    oprot.trans.flush()
8217 
 
8218 
  def process_getCountForFlipkartItems(self, seqid, iprot, oprot):
8219 
    args = getCountForFlipkartItems_args()
8220 
    args.read(iprot)
8221 
    iprot.readMessageEnd()
8222 
    result = getCountForFlipkartItems_result()
8223 
    result.success = self._handler.getCountForFlipkartItems()
8224 
    oprot.writeMessageBegin("getCountForFlipkartItems", TMessageType.REPLY, seqid)
8225 
    result.write(oprot)
8226 
    oprot.writeMessageEnd()
8227 
    oprot.trans.flush()
8228 
 
8229 
  def process_getFlipkartSearchResultCount(self, seqid, iprot, oprot):
8230 
    args = getFlipkartSearchResultCount_args()
8231 
    args.read(iprot)
8232 
    iprot.readMessageEnd()
8233 
    result = getFlipkartSearchResultCount_result()
8234 
    result.success = self._handler.getFlipkartSearchResultCount(args.searchTerm)
8235 
    oprot.writeMessageBegin("getFlipkartSearchResultCount", TMessageType.REPLY, seqid)
8236 
    result.write(oprot)
8237 
    oprot.writeMessageEnd()
8238 
    oprot.trans.flush()
8239 
 
8240 
  def process_getAllFkItems(self, seqid, iprot, oprot):
8241 
    args = getAllFkItems_args()
8242 
    args.read(iprot)
8243 
    iprot.readMessageEnd()
8244 
    result = getAllFkItems_result()
8245 
    result.success = self._handler.getAllFkItems()
8246 
    oprot.writeMessageBegin("getAllFkItems", TMessageType.REPLY, seqid)
8247 
    result.write(oprot)
8248 
    oprot.writeMessageEnd()
8249 
    oprot.trans.flush()
8250 
 
10140 vikram.rag 8251 
  def process_getFlipkartItemBySkyAtFlipkart(self, seqid, iprot, oprot):
8252 
    args = getFlipkartItemBySkyAtFlipkart_args()
8253 
    args.read(iprot)
8254 
    iprot.readMessageEnd()
8255 
    result = getFlipkartItemBySkyAtFlipkart_result()
8256 
    result.success = self._handler.getFlipkartItemBySkyAtFlipkart(args.sku)
8257 
    oprot.writeMessageBegin("getFlipkartItemBySkyAtFlipkart", TMessageType.REPLY, seqid)
8258 
    result.write(oprot)
8259 
    oprot.writeMessageEnd()
8260 
    oprot.trans.flush()
10097 kshitij.so 8261 
 
11015 kshitij.so 8262 
  def process_getMarketplaceHistory(self, seqid, iprot, oprot):
8263 
    args = getMarketplaceHistory_args()
8264 
    args.read(iprot)
8265 
    iprot.readMessageEnd()
8266 
    result = getMarketplaceHistory_result()
8267 
    result.success = self._handler.getMarketplaceHistory(args.source, args.offset, args.itemId)
8268 
    oprot.writeMessageBegin("getMarketplaceHistory", TMessageType.REPLY, seqid)
8269 
    result.write(oprot)
8270 
    oprot.writeMessageEnd()
8271 
    oprot.trans.flush()
8272 
 
10909 vikram.rag 8273 
  def process_getAllFbbListedItems(self, seqid, iprot, oprot):
8274 
    args = getAllFbbListedItems_args()
8275 
    args.read(iprot)
8276 
    iprot.readMessageEnd()
8277 
    result = getAllFbbListedItems_result()
8278 
    result.success = self._handler.getAllFbbListedItems()
8279 
    oprot.writeMessageBegin("getAllFbbListedItems", TMessageType.REPLY, seqid)
8280 
    result.write(oprot)
8281 
    oprot.writeMessageEnd()
8282 
    oprot.trans.flush()
10140 vikram.rag 8283 
 
10924 vikram.rag 8284 
  def process_getAllFbbPricingItems(self, seqid, iprot, oprot):
8285 
    args = getAllFbbPricingItems_args()
8286 
    args.read(iprot)
8287 
    iprot.readMessageEnd()
8288 
    result = getAllFbbPricingItems_result()
8289 
    result.success = self._handler.getAllFbbPricingItems()
8290 
    oprot.writeMessageBegin("getAllFbbPricingItems", TMessageType.REPLY, seqid)
8291 
    result.write(oprot)
8292 
    oprot.writeMessageEnd()
8293 
    oprot.trans.flush()
10909 vikram.rag 8294 
 
11015 kshitij.so 8295 
  def process_getCountForMarketplaceHistory(self, seqid, iprot, oprot):
8296 
    args = getCountForMarketplaceHistory_args()
8297 
    args.read(iprot)
8298 
    iprot.readMessageEnd()
8299 
    result = getCountForMarketplaceHistory_result()
8300 
    result.success = self._handler.getCountForMarketplaceHistory(args.source, args.itemId)
8301 
    oprot.writeMessageBegin("getCountForMarketplaceHistory", TMessageType.REPLY, seqid)
8302 
    result.write(oprot)
8303 
    oprot.writeMessageEnd()
8304 
    oprot.trans.flush()
10924 vikram.rag 8305 
 
11015 kshitij.so 8306 
  def process_getMarketplaceHistoryByDate(self, seqid, iprot, oprot):
8307 
    args = getMarketplaceHistoryByDate_args()
8308 
    args.read(iprot)
8309 
    iprot.readMessageEnd()
8310 
    result = getMarketplaceHistoryByDate_result()
8311 
    result.success = self._handler.getMarketplaceHistoryByDate(args.source, args.startDate, args.endDate, args.offset, args.limit, args.itemId)
8312 
    oprot.writeMessageBegin("getMarketplaceHistoryByDate", TMessageType.REPLY, seqid)
8313 
    result.write(oprot)
8314 
    oprot.writeMessageEnd()
8315 
    oprot.trans.flush()
8316 
 
11531 vikram.rag 8317 
  def process_getPrivateDealDetails(self, seqid, iprot, oprot):
8318 
    args = getPrivateDealDetails_args()
8319 
    args.read(iprot)
8320 
    iprot.readMessageEnd()
8321 
    result = getPrivateDealDetails_result()
8322 
    result.success = self._handler.getPrivateDealDetails(args.item_id)
8323 
    oprot.writeMessageBegin("getPrivateDealDetails", TMessageType.REPLY, seqid)
8324 
    result.write(oprot)
8325 
    oprot.writeMessageEnd()
8326 
    oprot.trans.flush()
11015 kshitij.so 8327 
 
11531 vikram.rag 8328 
  def process_getPrivateDealItems(self, seqid, iprot, oprot):
8329 
    args = getPrivateDealItems_args()
8330 
    args.read(iprot)
8331 
    iprot.readMessageEnd()
8332 
    result = getPrivateDealItems_result()
8333 
    result.success = self._handler.getPrivateDealItems(args.offset, args.limit)
8334 
    oprot.writeMessageBegin("getPrivateDealItems", TMessageType.REPLY, seqid)
8335 
    result.write(oprot)
8336 
    oprot.writeMessageEnd()
8337 
    oprot.trans.flush()
8338 
 
11592 amit.gupta 8339 
  def process_getAllActivePrivateDeals(self, seqid, iprot, oprot):
8340 
    args = getAllActivePrivateDeals_args()
8341 
    args.read(iprot)
8342 
    iprot.readMessageEnd()
8343 
    result = getAllActivePrivateDeals_result()
11653 amit.gupta 8344 
    result.success = self._handler.getAllActivePrivateDeals(args.itemIds, args.daysDelta)
11592 amit.gupta 8345 
    oprot.writeMessageBegin("getAllActivePrivateDeals", TMessageType.REPLY, seqid)
8346 
    result.write(oprot)
8347 
    oprot.writeMessageEnd()
8348 
    oprot.trans.flush()
8349 
 
11531 vikram.rag 8350 
  def process_addOrUpdatePrivateDeal(self, seqid, iprot, oprot):
8351 
    args = addOrUpdatePrivateDeal_args()
8352 
    args.read(iprot)
8353 
    iprot.readMessageEnd()
8354 
    result = addOrUpdatePrivateDeal_result()
8355 
    result.success = self._handler.addOrUpdatePrivateDeal(args.privateDeal)
8356 
    oprot.writeMessageBegin("addOrUpdatePrivateDeal", TMessageType.REPLY, seqid)
8357 
    result.write(oprot)
8358 
    oprot.writeMessageEnd()
8359 
    oprot.trans.flush()
8360 
 
11635 vikram.rag 8361 
  def process_getPrivateDealsCatalogIds(self, seqid, iprot, oprot):
8362 
    args = getPrivateDealsCatalogIds_args()
8363 
    args.read(iprot)
8364 
    iprot.readMessageEnd()
8365 
    result = getPrivateDealsCatalogIds_result()
8366 
    try:
8367 
      result.success = self._handler.getPrivateDealsCatalogIds(args.beginIndex, args.totalItems)
8368 
    except CatalogServiceException, cex:
8369 
      result.cex = cex
8370 
    oprot.writeMessageBegin("getPrivateDealsCatalogIds", TMessageType.REPLY, seqid)
8371 
    result.write(oprot)
8372 
    oprot.writeMessageEnd()
8373 
    oprot.trans.flush()
11531 vikram.rag 8374 
 
11645 amit.gupta 8375 
  def process_getPrivateDealsCount(self, seqid, iprot, oprot):
8376 
    args = getPrivateDealsCount_args()
8377 
    args.read(iprot)
8378 
    iprot.readMessageEnd()
8379 
    result = getPrivateDealsCount_result()
8380 
    result.success = self._handler.getPrivateDealsCount()
8381 
    oprot.writeMessageBegin("getPrivateDealsCount", TMessageType.REPLY, seqid)
8382 
    result.write(oprot)
8383 
    oprot.writeMessageEnd()
8384 
    oprot.trans.flush()
11635 vikram.rag 8385 
 
11645 amit.gupta 8386 
 
5944 mandeep.dh 8387 
# HELPER FUNCTIONS AND STRUCTURES
8388 
 
8389 
class addItem_args:
8390 
  """
8391 
  Attributes:
8392 
   - item
8393 
  """
8394 
 
8395 
  thrift_spec = (
8396 
    None, # 0
8397 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
8398 
  )
8399 
 
8400 
  def __init__(self, item=None,):
8401 
    self.item = item
8402 
 
8403 
  def read(self, iprot):
8404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8406 
      return
8407 
    iprot.readStructBegin()
8408 
    while True:
8409 
      (fname, ftype, fid) = iprot.readFieldBegin()
8410 
      if ftype == TType.STOP:
8411 
        break
8412 
      if fid == 1:
8413 
        if ftype == TType.STRUCT:
8414 
          self.item = Item()
8415 
          self.item.read(iprot)
8416 
        else:
8417 
          iprot.skip(ftype)
8418 
      else:
8419 
        iprot.skip(ftype)
8420 
      iprot.readFieldEnd()
8421 
    iprot.readStructEnd()
8422 
 
8423 
  def write(self, oprot):
8424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8426 
      return
8427 
    oprot.writeStructBegin('addItem_args')
8428 
    if self.item is not None:
8429 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
8430 
      self.item.write(oprot)
8431 
      oprot.writeFieldEnd()
8432 
    oprot.writeFieldStop()
8433 
    oprot.writeStructEnd()
8434 
 
8435 
  def validate(self):
8436 
    return
8437 
 
8438 
 
8439 
  def __repr__(self):
8440 
    L = ['%s=%r' % (key, value)
8441 
      for key, value in self.__dict__.iteritems()]
8442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8443 
 
8444 
  def __eq__(self, other):
8445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8446 
 
8447 
  def __ne__(self, other):
8448 
    return not (self == other)
8449 
 
8450 
class addItem_result:
8451 
  """
8452 
  Attributes:
8453 
   - success
8454 
   - cex
8455 
  """
8456 
 
8457 
  thrift_spec = (
8458 
    (0, TType.I64, 'success', None, None, ), # 0
8459 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8460 
  )
8461 
 
8462 
  def __init__(self, success=None, cex=None,):
8463 
    self.success = success
8464 
    self.cex = cex
8465 
 
8466 
  def read(self, iprot):
8467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8469 
      return
8470 
    iprot.readStructBegin()
8471 
    while True:
8472 
      (fname, ftype, fid) = iprot.readFieldBegin()
8473 
      if ftype == TType.STOP:
8474 
        break
8475 
      if fid == 0:
8476 
        if ftype == TType.I64:
8477 
          self.success = iprot.readI64();
8478 
        else:
8479 
          iprot.skip(ftype)
8480 
      elif fid == 1:
8481 
        if ftype == TType.STRUCT:
8482 
          self.cex = CatalogServiceException()
8483 
          self.cex.read(iprot)
8484 
        else:
8485 
          iprot.skip(ftype)
8486 
      else:
8487 
        iprot.skip(ftype)
8488 
      iprot.readFieldEnd()
8489 
    iprot.readStructEnd()
8490 
 
8491 
  def write(self, oprot):
8492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8494 
      return
8495 
    oprot.writeStructBegin('addItem_result')
8496 
    if self.success is not None:
8497 
      oprot.writeFieldBegin('success', TType.I64, 0)
8498 
      oprot.writeI64(self.success)
8499 
      oprot.writeFieldEnd()
8500 
    if self.cex is not None:
8501 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8502 
      self.cex.write(oprot)
8503 
      oprot.writeFieldEnd()
8504 
    oprot.writeFieldStop()
8505 
    oprot.writeStructEnd()
8506 
 
8507 
  def validate(self):
8508 
    return
8509 
 
8510 
 
8511 
  def __repr__(self):
8512 
    L = ['%s=%r' % (key, value)
8513 
      for key, value in self.__dict__.iteritems()]
8514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8515 
 
8516 
  def __eq__(self, other):
8517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8518 
 
8519 
  def __ne__(self, other):
8520 
    return not (self == other)
8521 
 
8522 
class updateItem_args:
8523 
  """
8524 
  Attributes:
8525 
   - item
8526 
  """
8527 
 
8528 
  thrift_spec = (
8529 
    None, # 0
8530 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
8531 
  )
8532 
 
8533 
  def __init__(self, item=None,):
8534 
    self.item = item
8535 
 
8536 
  def read(self, iprot):
8537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8539 
      return
8540 
    iprot.readStructBegin()
8541 
    while True:
8542 
      (fname, ftype, fid) = iprot.readFieldBegin()
8543 
      if ftype == TType.STOP:
8544 
        break
8545 
      if fid == 1:
8546 
        if ftype == TType.STRUCT:
8547 
          self.item = Item()
8548 
          self.item.read(iprot)
8549 
        else:
8550 
          iprot.skip(ftype)
8551 
      else:
8552 
        iprot.skip(ftype)
8553 
      iprot.readFieldEnd()
8554 
    iprot.readStructEnd()
8555 
 
8556 
  def write(self, oprot):
8557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8559 
      return
8560 
    oprot.writeStructBegin('updateItem_args')
8561 
    if self.item is not None:
8562 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
8563 
      self.item.write(oprot)
8564 
      oprot.writeFieldEnd()
8565 
    oprot.writeFieldStop()
8566 
    oprot.writeStructEnd()
8567 
 
8568 
  def validate(self):
8569 
    return
8570 
 
8571 
 
8572 
  def __repr__(self):
8573 
    L = ['%s=%r' % (key, value)
8574 
      for key, value in self.__dict__.iteritems()]
8575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8576 
 
8577 
  def __eq__(self, other):
8578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8579 
 
8580 
  def __ne__(self, other):
8581 
    return not (self == other)
8582 
 
8583 
class updateItem_result:
8584 
  """
8585 
  Attributes:
8586 
   - success
8587 
   - cex
8588 
  """
8589 
 
8590 
  thrift_spec = (
8591 
    (0, TType.I64, 'success', None, None, ), # 0
8592 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8593 
  )
8594 
 
8595 
  def __init__(self, success=None, cex=None,):
8596 
    self.success = success
8597 
    self.cex = cex
8598 
 
8599 
  def read(self, iprot):
8600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8602 
      return
8603 
    iprot.readStructBegin()
8604 
    while True:
8605 
      (fname, ftype, fid) = iprot.readFieldBegin()
8606 
      if ftype == TType.STOP:
8607 
        break
8608 
      if fid == 0:
8609 
        if ftype == TType.I64:
8610 
          self.success = iprot.readI64();
8611 
        else:
8612 
          iprot.skip(ftype)
8613 
      elif fid == 1:
8614 
        if ftype == TType.STRUCT:
8615 
          self.cex = CatalogServiceException()
8616 
          self.cex.read(iprot)
8617 
        else:
8618 
          iprot.skip(ftype)
8619 
      else:
8620 
        iprot.skip(ftype)
8621 
      iprot.readFieldEnd()
8622 
    iprot.readStructEnd()
8623 
 
8624 
  def write(self, oprot):
8625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8627 
      return
8628 
    oprot.writeStructBegin('updateItem_result')
8629 
    if self.success is not None:
8630 
      oprot.writeFieldBegin('success', TType.I64, 0)
8631 
      oprot.writeI64(self.success)
8632 
      oprot.writeFieldEnd()
8633 
    if self.cex is not None:
8634 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8635 
      self.cex.write(oprot)
8636 
      oprot.writeFieldEnd()
8637 
    oprot.writeFieldStop()
8638 
    oprot.writeStructEnd()
8639 
 
8640 
  def validate(self):
8641 
    return
8642 
 
8643 
 
8644 
  def __repr__(self):
8645 
    L = ['%s=%r' % (key, value)
8646 
      for key, value in self.__dict__.iteritems()]
8647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8648 
 
8649 
  def __eq__(self, other):
8650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8651 
 
8652 
  def __ne__(self, other):
8653 
    return not (self == other)
8654 
 
8655 
class isActive_args:
8656 
  """
8657 
  Attributes:
8658 
   - itemId
8659 
  """
8660 
 
8661 
  thrift_spec = (
8662 
    None, # 0
8663 
    (1, TType.I64, 'itemId', None, None, ), # 1
8664 
  )
8665 
 
8666 
  def __init__(self, itemId=None,):
8667 
    self.itemId = itemId
8668 
 
8669 
  def read(self, iprot):
8670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8672 
      return
8673 
    iprot.readStructBegin()
8674 
    while True:
8675 
      (fname, ftype, fid) = iprot.readFieldBegin()
8676 
      if ftype == TType.STOP:
8677 
        break
8678 
      if fid == 1:
8679 
        if ftype == TType.I64:
8680 
          self.itemId = iprot.readI64();
8681 
        else:
8682 
          iprot.skip(ftype)
8683 
      else:
8684 
        iprot.skip(ftype)
8685 
      iprot.readFieldEnd()
8686 
    iprot.readStructEnd()
8687 
 
8688 
  def write(self, oprot):
8689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8691 
      return
8692 
    oprot.writeStructBegin('isActive_args')
8693 
    if self.itemId is not None:
8694 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8695 
      oprot.writeI64(self.itemId)
8696 
      oprot.writeFieldEnd()
8697 
    oprot.writeFieldStop()
8698 
    oprot.writeStructEnd()
8699 
 
8700 
  def validate(self):
8701 
    return
8702 
 
8703 
 
8704 
  def __repr__(self):
8705 
    L = ['%s=%r' % (key, value)
8706 
      for key, value in self.__dict__.iteritems()]
8707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8708 
 
8709 
  def __eq__(self, other):
8710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8711 
 
8712 
  def __ne__(self, other):
8713 
    return not (self == other)
8714 
 
8715 
class isActive_result:
8716 
  """
8717 
  Attributes:
8718 
   - success
8719 
   - isex
8720 
  """
8721 
 
8722 
  thrift_spec = (
8723 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
8724 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8725 
  )
8726 
 
8727 
  def __init__(self, success=None, isex=None,):
8728 
    self.success = success
8729 
    self.isex = isex
8730 
 
8731 
  def read(self, iprot):
8732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8734 
      return
8735 
    iprot.readStructBegin()
8736 
    while True:
8737 
      (fname, ftype, fid) = iprot.readFieldBegin()
8738 
      if ftype == TType.STOP:
8739 
        break
8740 
      if fid == 0:
8741 
        if ftype == TType.STRUCT:
8742 
          self.success = ItemShippingInfo()
8743 
          self.success.read(iprot)
8744 
        else:
8745 
          iprot.skip(ftype)
8746 
      elif fid == 1:
8747 
        if ftype == TType.STRUCT:
8748 
          self.isex = CatalogServiceException()
8749 
          self.isex.read(iprot)
8750 
        else:
8751 
          iprot.skip(ftype)
8752 
      else:
8753 
        iprot.skip(ftype)
8754 
      iprot.readFieldEnd()
8755 
    iprot.readStructEnd()
8756 
 
8757 
  def write(self, oprot):
8758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8760 
      return
8761 
    oprot.writeStructBegin('isActive_result')
8762 
    if self.success is not None:
8763 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8764 
      self.success.write(oprot)
8765 
      oprot.writeFieldEnd()
8766 
    if self.isex is not None:
8767 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8768 
      self.isex.write(oprot)
8769 
      oprot.writeFieldEnd()
8770 
    oprot.writeFieldStop()
8771 
    oprot.writeStructEnd()
8772 
 
8773 
  def validate(self):
8774 
    return
8775 
 
8776 
 
8777 
  def __repr__(self):
8778 
    L = ['%s=%r' % (key, value)
8779 
      for key, value in self.__dict__.iteritems()]
8780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8781 
 
8782 
  def __eq__(self, other):
8783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8784 
 
8785 
  def __ne__(self, other):
8786 
    return not (self == other)
8787 
 
7438 amit.gupta 8788 
class getItemsStatus_args:
8789 
  """
8790 
  Attributes:
8791 
   - itemIds
8792 
  """
8793 
 
8794 
  thrift_spec = (
8795 
    None, # 0
8796 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
8797 
  )
8798 
 
8799 
  def __init__(self, itemIds=None,):
8800 
    self.itemIds = itemIds
8801 
 
8802 
  def read(self, iprot):
8803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8805 
      return
8806 
    iprot.readStructBegin()
8807 
    while True:
8808 
      (fname, ftype, fid) = iprot.readFieldBegin()
8809 
      if ftype == TType.STOP:
8810 
        break
8811 
      if fid == 1:
8812 
        if ftype == TType.LIST:
8813 
          self.itemIds = []
8590 kshitij.so 8814 
          (_etype33, _size30) = iprot.readListBegin()
8815 
          for _i34 in xrange(_size30):
8816 
            _elem35 = iprot.readI64();
8817 
            self.itemIds.append(_elem35)
7438 amit.gupta 8818 
          iprot.readListEnd()
8819 
        else:
8820 
          iprot.skip(ftype)
8821 
      else:
8822 
        iprot.skip(ftype)
8823 
      iprot.readFieldEnd()
8824 
    iprot.readStructEnd()
8825 
 
8826 
  def write(self, oprot):
8827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8829 
      return
8830 
    oprot.writeStructBegin('getItemsStatus_args')
8831 
    if self.itemIds is not None:
8832 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
8833 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 8834 
      for iter36 in self.itemIds:
8835 
        oprot.writeI64(iter36)
7438 amit.gupta 8836 
      oprot.writeListEnd()
8837 
      oprot.writeFieldEnd()
8838 
    oprot.writeFieldStop()
8839 
    oprot.writeStructEnd()
8840 
 
8841 
  def validate(self):
8842 
    return
8843 
 
8844 
 
8845 
  def __repr__(self):
8846 
    L = ['%s=%r' % (key, value)
8847 
      for key, value in self.__dict__.iteritems()]
8848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8849 
 
8850 
  def __eq__(self, other):
8851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8852 
 
8853 
  def __ne__(self, other):
8854 
    return not (self == other)
8855 
 
8856 
class getItemsStatus_result:
8857 
  """
8858 
  Attributes:
8859 
   - success
8860 
   - isex
8861 
  """
8862 
 
8863 
  thrift_spec = (
8864 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
8865 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8866 
  )
8867 
 
8868 
  def __init__(self, success=None, isex=None,):
8869 
    self.success = success
8870 
    self.isex = isex
8871 
 
8872 
  def read(self, iprot):
8873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8875 
      return
8876 
    iprot.readStructBegin()
8877 
    while True:
8878 
      (fname, ftype, fid) = iprot.readFieldBegin()
8879 
      if ftype == TType.STOP:
8880 
        break
8881 
      if fid == 0:
8882 
        if ftype == TType.MAP:
8883 
          self.success = {}
8590 kshitij.so 8884 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
8885 
          for _i41 in xrange(_size37):
8886 
            _key42 = iprot.readI64();
8887 
            _val43 = iprot.readBool();
8888 
            self.success[_key42] = _val43
7438 amit.gupta 8889 
          iprot.readMapEnd()
8890 
        else:
8891 
          iprot.skip(ftype)
8892 
      elif fid == 1:
8893 
        if ftype == TType.STRUCT:
8894 
          self.isex = CatalogServiceException()
8895 
          self.isex.read(iprot)
8896 
        else:
8897 
          iprot.skip(ftype)
8898 
      else:
8899 
        iprot.skip(ftype)
8900 
      iprot.readFieldEnd()
8901 
    iprot.readStructEnd()
8902 
 
8903 
  def write(self, oprot):
8904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8906 
      return
8907 
    oprot.writeStructBegin('getItemsStatus_result')
8908 
    if self.success is not None:
8909 
      oprot.writeFieldBegin('success', TType.MAP, 0)
8910 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 8911 
      for kiter44,viter45 in self.success.items():
8912 
        oprot.writeI64(kiter44)
8913 
        oprot.writeBool(viter45)
7438 amit.gupta 8914 
      oprot.writeMapEnd()
8915 
      oprot.writeFieldEnd()
8916 
    if self.isex is not None:
8917 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8918 
      self.isex.write(oprot)
8919 
      oprot.writeFieldEnd()
8920 
    oprot.writeFieldStop()
8921 
    oprot.writeStructEnd()
8922 
 
8923 
  def validate(self):
8924 
    return
8925 
 
8926 
 
8927 
  def __repr__(self):
8928 
    L = ['%s=%r' % (key, value)
8929 
      for key, value in self.__dict__.iteritems()]
8930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8931 
 
8932 
  def __eq__(self, other):
8933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8934 
 
8935 
  def __ne__(self, other):
8936 
    return not (self == other)
8937 
 
5944 mandeep.dh 8938 
class getItemStatusDescription_args:
8939 
  """
8940 
  Attributes:
8941 
   - itemId
8942 
  """
8943 
 
8944 
  thrift_spec = (
8945 
    None, # 0
8946 
    (1, TType.I64, 'itemId', None, None, ), # 1
8947 
  )
8948 
 
8949 
  def __init__(self, itemId=None,):
8950 
    self.itemId = itemId
8951 
 
8952 
  def read(self, iprot):
8953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8955 
      return
8956 
    iprot.readStructBegin()
8957 
    while True:
8958 
      (fname, ftype, fid) = iprot.readFieldBegin()
8959 
      if ftype == TType.STOP:
8960 
        break
8961 
      if fid == 1:
8962 
        if ftype == TType.I64:
8963 
          self.itemId = iprot.readI64();
8964 
        else:
8965 
          iprot.skip(ftype)
8966 
      else:
8967 
        iprot.skip(ftype)
8968 
      iprot.readFieldEnd()
8969 
    iprot.readStructEnd()
8970 
 
8971 
  def write(self, oprot):
8972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8974 
      return
8975 
    oprot.writeStructBegin('getItemStatusDescription_args')
8976 
    if self.itemId is not None:
8977 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8978 
      oprot.writeI64(self.itemId)
8979 
      oprot.writeFieldEnd()
8980 
    oprot.writeFieldStop()
8981 
    oprot.writeStructEnd()
8982 
 
8983 
  def validate(self):
8984 
    return
8985 
 
8986 
 
8987 
  def __repr__(self):
8988 
    L = ['%s=%r' % (key, value)
8989 
      for key, value in self.__dict__.iteritems()]
8990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8991 
 
8992 
  def __eq__(self, other):
8993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8994 
 
8995 
  def __ne__(self, other):
8996 
    return not (self == other)
8997 
 
8998 
class getItemStatusDescription_result:
8999 
  """
9000 
  Attributes:
9001 
   - success
9002 
   - isex
9003 
  """
9004 
 
9005 
  thrift_spec = (
9006 
    (0, TType.STRING, 'success', None, None, ), # 0
9007 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9008 
  )
9009 
 
9010 
  def __init__(self, success=None, isex=None,):
9011 
    self.success = success
9012 
    self.isex = isex
9013 
 
9014 
  def read(self, iprot):
9015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9017 
      return
9018 
    iprot.readStructBegin()
9019 
    while True:
9020 
      (fname, ftype, fid) = iprot.readFieldBegin()
9021 
      if ftype == TType.STOP:
9022 
        break
9023 
      if fid == 0:
9024 
        if ftype == TType.STRING:
9025 
          self.success = iprot.readString();
9026 
        else:
9027 
          iprot.skip(ftype)
9028 
      elif fid == 1:
9029 
        if ftype == TType.STRUCT:
9030 
          self.isex = CatalogServiceException()
9031 
          self.isex.read(iprot)
9032 
        else:
9033 
          iprot.skip(ftype)
9034 
      else:
9035 
        iprot.skip(ftype)
9036 
      iprot.readFieldEnd()
9037 
    iprot.readStructEnd()
9038 
 
9039 
  def write(self, oprot):
9040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9042 
      return
9043 
    oprot.writeStructBegin('getItemStatusDescription_result')
9044 
    if self.success is not None:
9045 
      oprot.writeFieldBegin('success', TType.STRING, 0)
9046 
      oprot.writeString(self.success)
9047 
      oprot.writeFieldEnd()
9048 
    if self.isex is not None:
9049 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9050 
      self.isex.write(oprot)
9051 
      oprot.writeFieldEnd()
9052 
    oprot.writeFieldStop()
9053 
    oprot.writeStructEnd()
9054 
 
9055 
  def validate(self):
9056 
    return
9057 
 
9058 
 
9059 
  def __repr__(self):
9060 
    L = ['%s=%r' % (key, value)
9061 
      for key, value in self.__dict__.iteritems()]
9062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9063 
 
9064 
  def __eq__(self, other):
9065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9066 
 
9067 
  def __ne__(self, other):
9068 
    return not (self == other)
9069 
 
9070 
class startItemOn_args:
9071 
  """
9072 
  Attributes:
9073 
   - item_id
9074 
   - timestamp
9075 
  """
9076 
 
9077 
  thrift_spec = (
9078 
    None, # 0
9079 
    (1, TType.I64, 'item_id', None, None, ), # 1
9080 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9081 
  )
9082 
 
9083 
  def __init__(self, item_id=None, timestamp=None,):
9084 
    self.item_id = item_id
9085 
    self.timestamp = timestamp
9086 
 
9087 
  def read(self, iprot):
9088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9090 
      return
9091 
    iprot.readStructBegin()
9092 
    while True:
9093 
      (fname, ftype, fid) = iprot.readFieldBegin()
9094 
      if ftype == TType.STOP:
9095 
        break
9096 
      if fid == 1:
9097 
        if ftype == TType.I64:
9098 
          self.item_id = iprot.readI64();
9099 
        else:
9100 
          iprot.skip(ftype)
9101 
      elif fid == 2:
9102 
        if ftype == TType.I64:
9103 
          self.timestamp = iprot.readI64();
9104 
        else:
9105 
          iprot.skip(ftype)
9106 
      else:
9107 
        iprot.skip(ftype)
9108 
      iprot.readFieldEnd()
9109 
    iprot.readStructEnd()
9110 
 
9111 
  def write(self, oprot):
9112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9114 
      return
9115 
    oprot.writeStructBegin('startItemOn_args')
9116 
    if self.item_id is not None:
9117 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9118 
      oprot.writeI64(self.item_id)
9119 
      oprot.writeFieldEnd()
9120 
    if self.timestamp is not None:
9121 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
9122 
      oprot.writeI64(self.timestamp)
9123 
      oprot.writeFieldEnd()
9124 
    oprot.writeFieldStop()
9125 
    oprot.writeStructEnd()
9126 
 
9127 
  def validate(self):
9128 
    return
9129 
 
9130 
 
9131 
  def __repr__(self):
9132 
    L = ['%s=%r' % (key, value)
9133 
      for key, value in self.__dict__.iteritems()]
9134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9135 
 
9136 
  def __eq__(self, other):
9137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9138 
 
9139 
  def __ne__(self, other):
9140 
    return not (self == other)
9141 
 
9142 
class startItemOn_result:
9143 
  """
9144 
  Attributes:
9145 
   - cex
9146 
  """
9147 
 
9148 
  thrift_spec = (
9149 
    None, # 0
9150 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9151 
  )
9152 
 
9153 
  def __init__(self, cex=None,):
9154 
    self.cex = cex
9155 
 
9156 
  def read(self, iprot):
9157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9159 
      return
9160 
    iprot.readStructBegin()
9161 
    while True:
9162 
      (fname, ftype, fid) = iprot.readFieldBegin()
9163 
      if ftype == TType.STOP:
9164 
        break
9165 
      if fid == 1:
9166 
        if ftype == TType.STRUCT:
9167 
          self.cex = CatalogServiceException()
9168 
          self.cex.read(iprot)
9169 
        else:
9170 
          iprot.skip(ftype)
9171 
      else:
9172 
        iprot.skip(ftype)
9173 
      iprot.readFieldEnd()
9174 
    iprot.readStructEnd()
9175 
 
9176 
  def write(self, oprot):
9177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9179 
      return
9180 
    oprot.writeStructBegin('startItemOn_result')
9181 
    if self.cex is not None:
9182 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9183 
      self.cex.write(oprot)
9184 
      oprot.writeFieldEnd()
9185 
    oprot.writeFieldStop()
9186 
    oprot.writeStructEnd()
9187 
 
9188 
  def validate(self):
9189 
    return
9190 
 
9191 
 
9192 
  def __repr__(self):
9193 
    L = ['%s=%r' % (key, value)
9194 
      for key, value in self.__dict__.iteritems()]
9195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9196 
 
9197 
  def __eq__(self, other):
9198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9199 
 
9200 
  def __ne__(self, other):
9201 
    return not (self == other)
9202 
 
9203 
class retireItemOn_args:
9204 
  """
9205 
  Attributes:
9206 
   - item_id
9207 
   - timestamp
9208 
  """
9209 
 
9210 
  thrift_spec = (
9211 
    None, # 0
9212 
    (1, TType.I64, 'item_id', None, None, ), # 1
9213 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9214 
  )
9215 
 
9216 
  def __init__(self, item_id=None, timestamp=None,):
9217 
    self.item_id = item_id
9218 
    self.timestamp = timestamp
9219 
 
9220 
  def read(self, iprot):
9221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9223 
      return
9224 
    iprot.readStructBegin()
9225 
    while True:
9226 
      (fname, ftype, fid) = iprot.readFieldBegin()
9227 
      if ftype == TType.STOP:
9228 
        break
9229 
      if fid == 1:
9230 
        if ftype == TType.I64:
9231 
          self.item_id = iprot.readI64();
9232 
        else:
9233 
          iprot.skip(ftype)
9234 
      elif fid == 2:
9235 
        if ftype == TType.I64:
9236 
          self.timestamp = iprot.readI64();
9237 
        else:
9238 
          iprot.skip(ftype)
9239 
      else:
9240 
        iprot.skip(ftype)
9241 
      iprot.readFieldEnd()
9242 
    iprot.readStructEnd()
9243 
 
9244 
  def write(self, oprot):
9245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9247 
      return
9248 
    oprot.writeStructBegin('retireItemOn_args')
9249 
    if self.item_id is not None:
9250 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9251 
      oprot.writeI64(self.item_id)
9252 
      oprot.writeFieldEnd()
9253 
    if self.timestamp is not None:
9254 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
9255 
      oprot.writeI64(self.timestamp)
9256 
      oprot.writeFieldEnd()
9257 
    oprot.writeFieldStop()
9258 
    oprot.writeStructEnd()
9259 
 
9260 
  def validate(self):
9261 
    return
9262 
 
9263 
 
9264 
  def __repr__(self):
9265 
    L = ['%s=%r' % (key, value)
9266 
      for key, value in self.__dict__.iteritems()]
9267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9268 
 
9269 
  def __eq__(self, other):
9270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9271 
 
9272 
  def __ne__(self, other):
9273 
    return not (self == other)
9274 
 
9275 
class retireItemOn_result:
9276 
  """
9277 
  Attributes:
9278 
   - cex
9279 
  """
9280 
 
9281 
  thrift_spec = (
9282 
    None, # 0
9283 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9284 
  )
9285 
 
9286 
  def __init__(self, cex=None,):
9287 
    self.cex = cex
9288 
 
9289 
  def read(self, iprot):
9290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9292 
      return
9293 
    iprot.readStructBegin()
9294 
    while True:
9295 
      (fname, ftype, fid) = iprot.readFieldBegin()
9296 
      if ftype == TType.STOP:
9297 
        break
9298 
      if fid == 1:
9299 
        if ftype == TType.STRUCT:
9300 
          self.cex = CatalogServiceException()
9301 
          self.cex.read(iprot)
9302 
        else:
9303 
          iprot.skip(ftype)
9304 
      else:
9305 
        iprot.skip(ftype)
9306 
      iprot.readFieldEnd()
9307 
    iprot.readStructEnd()
9308 
 
9309 
  def write(self, oprot):
9310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9312 
      return
9313 
    oprot.writeStructBegin('retireItemOn_result')
9314 
    if self.cex is not None:
9315 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9316 
      self.cex.write(oprot)
9317 
      oprot.writeFieldEnd()
9318 
    oprot.writeFieldStop()
9319 
    oprot.writeStructEnd()
9320 
 
9321 
  def validate(self):
9322 
    return
9323 
 
9324 
 
9325 
  def __repr__(self):
9326 
    L = ['%s=%r' % (key, value)
9327 
      for key, value in self.__dict__.iteritems()]
9328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9329 
 
9330 
  def __eq__(self, other):
9331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9332 
 
9333 
  def __ne__(self, other):
9334 
    return not (self == other)
9335 
 
9336 
class changeItemStatus_args:
9337 
  """
9338 
  Attributes:
9339 
   - item_id
9340 
   - timestamp
9341 
   - newstatus
9342 
  """
9343 
 
9344 
  thrift_spec = (
9345 
    None, # 0
9346 
    (1, TType.I64, 'item_id', None, None, ), # 1
9347 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9348 
    (3, TType.I32, 'newstatus', None, None, ), # 3
9349 
  )
9350 
 
9351 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
9352 
    self.item_id = item_id
9353 
    self.timestamp = timestamp
9354 
    self.newstatus = newstatus
9355 
 
9356 
  def read(self, iprot):
9357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9359 
      return
9360 
    iprot.readStructBegin()
9361 
    while True:
9362 
      (fname, ftype, fid) = iprot.readFieldBegin()
9363 
      if ftype == TType.STOP:
9364 
        break
9365 
      if fid == 1:
9366 
        if ftype == TType.I64:
9367 
          self.item_id = iprot.readI64();
9368 
        else:
9369 
          iprot.skip(ftype)
9370 
      elif fid == 2:
9371 
        if ftype == TType.I64:
9372 
          self.timestamp = iprot.readI64();
9373 
        else:
9374 
          iprot.skip(ftype)
9375 
      elif fid == 3:
9376 
        if ftype == TType.I32:
9377 
          self.newstatus = iprot.readI32();
9378 
        else:
9379 
          iprot.skip(ftype)
9380 
      else:
9381 
        iprot.skip(ftype)
9382 
      iprot.readFieldEnd()
9383 
    iprot.readStructEnd()
9384 
 
9385 
  def write(self, oprot):
9386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9388 
      return
9389 
    oprot.writeStructBegin('changeItemStatus_args')
9390 
    if self.item_id is not None:
9391 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9392 
      oprot.writeI64(self.item_id)
9393 
      oprot.writeFieldEnd()
9394 
    if self.timestamp is not None:
9395 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
9396 
      oprot.writeI64(self.timestamp)
9397 
      oprot.writeFieldEnd()
9398 
    if self.newstatus is not None:
9399 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
9400 
      oprot.writeI32(self.newstatus)
9401 
      oprot.writeFieldEnd()
9402 
    oprot.writeFieldStop()
9403 
    oprot.writeStructEnd()
9404 
 
9405 
  def validate(self):
9406 
    return
9407 
 
9408 
 
9409 
  def __repr__(self):
9410 
    L = ['%s=%r' % (key, value)
9411 
      for key, value in self.__dict__.iteritems()]
9412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9413 
 
9414 
  def __eq__(self, other):
9415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9416 
 
9417 
  def __ne__(self, other):
9418 
    return not (self == other)
9419 
 
9420 
class changeItemStatus_result:
9421 
  """
9422 
  Attributes:
9423 
   - cex
9424 
  """
9425 
 
9426 
  thrift_spec = (
9427 
    None, # 0
9428 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9429 
  )
9430 
 
9431 
  def __init__(self, cex=None,):
9432 
    self.cex = cex
9433 
 
9434 
  def read(self, iprot):
9435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9437 
      return
9438 
    iprot.readStructBegin()
9439 
    while True:
9440 
      (fname, ftype, fid) = iprot.readFieldBegin()
9441 
      if ftype == TType.STOP:
9442 
        break
9443 
      if fid == 1:
9444 
        if ftype == TType.STRUCT:
9445 
          self.cex = CatalogServiceException()
9446 
          self.cex.read(iprot)
9447 
        else:
9448 
          iprot.skip(ftype)
9449 
      else:
9450 
        iprot.skip(ftype)
9451 
      iprot.readFieldEnd()
9452 
    iprot.readStructEnd()
9453 
 
9454 
  def write(self, oprot):
9455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9457 
      return
9458 
    oprot.writeStructBegin('changeItemStatus_result')
9459 
    if self.cex is not None:
9460 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9461 
      self.cex.write(oprot)
9462 
      oprot.writeFieldEnd()
9463 
    oprot.writeFieldStop()
9464 
    oprot.writeStructEnd()
9465 
 
9466 
  def validate(self):
9467 
    return
9468 
 
9469 
 
9470 
  def __repr__(self):
9471 
    L = ['%s=%r' % (key, value)
9472 
      for key, value in self.__dict__.iteritems()]
9473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9474 
 
9475 
  def __eq__(self, other):
9476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9477 
 
9478 
  def __ne__(self, other):
9479 
    return not (self == other)
9480 
 
9481 
class getItem_args:
9482 
  """
9483 
  Attributes:
9484 
   - item_id
9485 
  """
9486 
 
9487 
  thrift_spec = (
9488 
    None, # 0
9489 
    (1, TType.I64, 'item_id', None, None, ), # 1
9490 
  )
9491 
 
9492 
  def __init__(self, item_id=None,):
9493 
    self.item_id = item_id
9494 
 
9495 
  def read(self, iprot):
9496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9498 
      return
9499 
    iprot.readStructBegin()
9500 
    while True:
9501 
      (fname, ftype, fid) = iprot.readFieldBegin()
9502 
      if ftype == TType.STOP:
9503 
        break
9504 
      if fid == 1:
9505 
        if ftype == TType.I64:
9506 
          self.item_id = iprot.readI64();
9507 
        else:
9508 
          iprot.skip(ftype)
9509 
      else:
9510 
        iprot.skip(ftype)
9511 
      iprot.readFieldEnd()
9512 
    iprot.readStructEnd()
9513 
 
9514 
  def write(self, oprot):
9515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9517 
      return
9518 
    oprot.writeStructBegin('getItem_args')
9519 
    if self.item_id is not None:
9520 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9521 
      oprot.writeI64(self.item_id)
9522 
      oprot.writeFieldEnd()
9523 
    oprot.writeFieldStop()
9524 
    oprot.writeStructEnd()
9525 
 
9526 
  def validate(self):
9527 
    return
9528 
 
9529 
 
9530 
  def __repr__(self):
9531 
    L = ['%s=%r' % (key, value)
9532 
      for key, value in self.__dict__.iteritems()]
9533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9534 
 
9535 
  def __eq__(self, other):
9536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9537 
 
9538 
  def __ne__(self, other):
9539 
    return not (self == other)
9540 
 
9541 
class getItem_result:
9542 
  """
9543 
  Attributes:
9544 
   - success
9545 
   - cex
9546 
  """
9547 
 
9548 
  thrift_spec = (
9549 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9550 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9551 
  )
9552 
 
9553 
  def __init__(self, success=None, cex=None,):
9554 
    self.success = success
9555 
    self.cex = cex
9556 
 
9557 
  def read(self, iprot):
9558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9560 
      return
9561 
    iprot.readStructBegin()
9562 
    while True:
9563 
      (fname, ftype, fid) = iprot.readFieldBegin()
9564 
      if ftype == TType.STOP:
9565 
        break
9566 
      if fid == 0:
9567 
        if ftype == TType.STRUCT:
9568 
          self.success = Item()
9569 
          self.success.read(iprot)
9570 
        else:
9571 
          iprot.skip(ftype)
9572 
      elif fid == 1:
9573 
        if ftype == TType.STRUCT:
9574 
          self.cex = CatalogServiceException()
9575 
          self.cex.read(iprot)
9576 
        else:
9577 
          iprot.skip(ftype)
9578 
      else:
9579 
        iprot.skip(ftype)
9580 
      iprot.readFieldEnd()
9581 
    iprot.readStructEnd()
9582 
 
9583 
  def write(self, oprot):
9584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9586 
      return
9587 
    oprot.writeStructBegin('getItem_result')
9588 
    if self.success is not None:
9589 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9590 
      self.success.write(oprot)
9591 
      oprot.writeFieldEnd()
9592 
    if self.cex is not None:
9593 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9594 
      self.cex.write(oprot)
9595 
      oprot.writeFieldEnd()
9596 
    oprot.writeFieldStop()
9597 
    oprot.writeStructEnd()
9598 
 
9599 
  def validate(self):
9600 
    return
9601 
 
9602 
 
9603 
  def __repr__(self):
9604 
    L = ['%s=%r' % (key, value)
9605 
      for key, value in self.__dict__.iteritems()]
9606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9607 
 
9608 
  def __eq__(self, other):
9609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9610 
 
9611 
  def __ne__(self, other):
9612 
    return not (self == other)
9613 
 
9614 
class getItemsByCatalogId_args:
9615 
  """
9616 
  Attributes:
9617 
   - catalog_item_id
9618 
  """
9619 
 
9620 
  thrift_spec = (
9621 
    None, # 0
9622 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
9623 
  )
9624 
 
9625 
  def __init__(self, catalog_item_id=None,):
9626 
    self.catalog_item_id = catalog_item_id
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.I64:
9639 
          self.catalog_item_id = iprot.readI64();
9640 
        else:
9641 
          iprot.skip(ftype)
9642 
      else:
9643 
        iprot.skip(ftype)
9644 
      iprot.readFieldEnd()
9645 
    iprot.readStructEnd()
9646 
 
9647 
  def write(self, oprot):
9648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9650 
      return
9651 
    oprot.writeStructBegin('getItemsByCatalogId_args')
9652 
    if self.catalog_item_id is not None:
9653 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
9654 
      oprot.writeI64(self.catalog_item_id)
9655 
      oprot.writeFieldEnd()
9656 
    oprot.writeFieldStop()
9657 
    oprot.writeStructEnd()
9658 
 
9659 
  def validate(self):
9660 
    return
9661 
 
9662 
 
9663 
  def __repr__(self):
9664 
    L = ['%s=%r' % (key, value)
9665 
      for key, value in self.__dict__.iteritems()]
9666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9667 
 
9668 
  def __eq__(self, other):
9669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9670 
 
9671 
  def __ne__(self, other):
9672 
    return not (self == other)
9673 
 
9674 
class getItemsByCatalogId_result:
9675 
  """
9676 
  Attributes:
9677 
   - success
9678 
   - cex
9679 
  """
9680 
 
9681 
  thrift_spec = (
9682 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9683 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9684 
  )
9685 
 
9686 
  def __init__(self, success=None, cex=None,):
9687 
    self.success = success
9688 
    self.cex = cex
9689 
 
9690 
  def read(self, iprot):
9691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9693 
      return
9694 
    iprot.readStructBegin()
9695 
    while True:
9696 
      (fname, ftype, fid) = iprot.readFieldBegin()
9697 
      if ftype == TType.STOP:
9698 
        break
9699 
      if fid == 0:
9700 
        if ftype == TType.LIST:
9701 
          self.success = []
8590 kshitij.so 9702 
          (_etype49, _size46) = iprot.readListBegin()
9703 
          for _i50 in xrange(_size46):
9704 
            _elem51 = Item()
9705 
            _elem51.read(iprot)
9706 
            self.success.append(_elem51)
5944 mandeep.dh 9707 
          iprot.readListEnd()
9708 
        else:
9709 
          iprot.skip(ftype)
9710 
      elif fid == 1:
9711 
        if ftype == TType.STRUCT:
9712 
          self.cex = CatalogServiceException()
9713 
          self.cex.read(iprot)
9714 
        else:
9715 
          iprot.skip(ftype)
9716 
      else:
9717 
        iprot.skip(ftype)
9718 
      iprot.readFieldEnd()
9719 
    iprot.readStructEnd()
9720 
 
9721 
  def write(self, oprot):
9722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9724 
      return
9725 
    oprot.writeStructBegin('getItemsByCatalogId_result')
9726 
    if self.success is not None:
9727 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9728 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9729 
      for iter52 in self.success:
9730 
        iter52.write(oprot)
5944 mandeep.dh 9731 
      oprot.writeListEnd()
9732 
      oprot.writeFieldEnd()
9733 
    if self.cex is not None:
9734 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9735 
      self.cex.write(oprot)
9736 
      oprot.writeFieldEnd()
9737 
    oprot.writeFieldStop()
9738 
    oprot.writeStructEnd()
9739 
 
9740 
  def validate(self):
9741 
    return
9742 
 
9743 
 
9744 
  def __repr__(self):
9745 
    L = ['%s=%r' % (key, value)
9746 
      for key, value in self.__dict__.iteritems()]
9747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9748 
 
9749 
  def __eq__(self, other):
9750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9751 
 
9752 
  def __ne__(self, other):
9753 
    return not (self == other)
9754 
 
9755 
class getValidItemsByCatalogId_args:
9756 
  """
9757 
  Attributes:
9758 
   - catalog_item_id
9759 
  """
9760 
 
9761 
  thrift_spec = (
9762 
    None, # 0
9763 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
9764 
  )
9765 
 
9766 
  def __init__(self, catalog_item_id=None,):
9767 
    self.catalog_item_id = catalog_item_id
9768 
 
9769 
  def read(self, iprot):
9770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9772 
      return
9773 
    iprot.readStructBegin()
9774 
    while True:
9775 
      (fname, ftype, fid) = iprot.readFieldBegin()
9776 
      if ftype == TType.STOP:
9777 
        break
9778 
      if fid == 1:
9779 
        if ftype == TType.I64:
9780 
          self.catalog_item_id = iprot.readI64();
9781 
        else:
9782 
          iprot.skip(ftype)
9783 
      else:
9784 
        iprot.skip(ftype)
9785 
      iprot.readFieldEnd()
9786 
    iprot.readStructEnd()
9787 
 
9788 
  def write(self, oprot):
9789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9791 
      return
9792 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
9793 
    if self.catalog_item_id is not None:
9794 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
9795 
      oprot.writeI64(self.catalog_item_id)
9796 
      oprot.writeFieldEnd()
9797 
    oprot.writeFieldStop()
9798 
    oprot.writeStructEnd()
9799 
 
9800 
  def validate(self):
9801 
    return
9802 
 
9803 
 
9804 
  def __repr__(self):
9805 
    L = ['%s=%r' % (key, value)
9806 
      for key, value in self.__dict__.iteritems()]
9807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9808 
 
9809 
  def __eq__(self, other):
9810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9811 
 
9812 
  def __ne__(self, other):
9813 
    return not (self == other)
9814 
 
9815 
class getValidItemsByCatalogId_result:
9816 
  """
9817 
  Attributes:
9818 
   - success
9819 
   - cex
9820 
  """
9821 
 
9822 
  thrift_spec = (
9823 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9824 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9825 
  )
9826 
 
9827 
  def __init__(self, success=None, cex=None,):
9828 
    self.success = success
9829 
    self.cex = cex
9830 
 
9831 
  def read(self, iprot):
9832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9834 
      return
9835 
    iprot.readStructBegin()
9836 
    while True:
9837 
      (fname, ftype, fid) = iprot.readFieldBegin()
9838 
      if ftype == TType.STOP:
9839 
        break
9840 
      if fid == 0:
9841 
        if ftype == TType.LIST:
9842 
          self.success = []
8590 kshitij.so 9843 
          (_etype56, _size53) = iprot.readListBegin()
9844 
          for _i57 in xrange(_size53):
9845 
            _elem58 = Item()
9846 
            _elem58.read(iprot)
9847 
            self.success.append(_elem58)
5944 mandeep.dh 9848 
          iprot.readListEnd()
9849 
        else:
9850 
          iprot.skip(ftype)
9851 
      elif fid == 1:
9852 
        if ftype == TType.STRUCT:
9853 
          self.cex = CatalogServiceException()
9854 
          self.cex.read(iprot)
9855 
        else:
9856 
          iprot.skip(ftype)
9857 
      else:
9858 
        iprot.skip(ftype)
9859 
      iprot.readFieldEnd()
9860 
    iprot.readStructEnd()
9861 
 
9862 
  def write(self, oprot):
9863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9865 
      return
9866 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
9867 
    if self.success is not None:
9868 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9869 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9870 
      for iter59 in self.success:
9871 
        iter59.write(oprot)
5944 mandeep.dh 9872 
      oprot.writeListEnd()
9873 
      oprot.writeFieldEnd()
9874 
    if self.cex is not None:
9875 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9876 
      self.cex.write(oprot)
9877 
      oprot.writeFieldEnd()
9878 
    oprot.writeFieldStop()
9879 
    oprot.writeStructEnd()
9880 
 
9881 
  def validate(self):
9882 
    return
9883 
 
9884 
 
9885 
  def __repr__(self):
9886 
    L = ['%s=%r' % (key, value)
9887 
      for key, value in self.__dict__.iteritems()]
9888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9889 
 
9890 
  def __eq__(self, other):
9891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9892 
 
9893 
  def __ne__(self, other):
9894 
    return not (self == other)
9895 
 
9896 
class getAllItems_args:
9897 
  """
9898 
  Attributes:
9899 
   - isActive
9900 
  """
9901 
 
9902 
  thrift_spec = (
9903 
    None, # 0
9904 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
9905 
  )
9906 
 
9907 
  def __init__(self, isActive=None,):
9908 
    self.isActive = isActive
9909 
 
9910 
  def read(self, iprot):
9911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9913 
      return
9914 
    iprot.readStructBegin()
9915 
    while True:
9916 
      (fname, ftype, fid) = iprot.readFieldBegin()
9917 
      if ftype == TType.STOP:
9918 
        break
9919 
      if fid == 1:
9920 
        if ftype == TType.BOOL:
9921 
          self.isActive = iprot.readBool();
9922 
        else:
9923 
          iprot.skip(ftype)
9924 
      else:
9925 
        iprot.skip(ftype)
9926 
      iprot.readFieldEnd()
9927 
    iprot.readStructEnd()
9928 
 
9929 
  def write(self, oprot):
9930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9932 
      return
9933 
    oprot.writeStructBegin('getAllItems_args')
9934 
    if self.isActive is not None:
9935 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
9936 
      oprot.writeBool(self.isActive)
9937 
      oprot.writeFieldEnd()
9938 
    oprot.writeFieldStop()
9939 
    oprot.writeStructEnd()
9940 
 
9941 
  def validate(self):
9942 
    return
9943 
 
9944 
 
9945 
  def __repr__(self):
9946 
    L = ['%s=%r' % (key, value)
9947 
      for key, value in self.__dict__.iteritems()]
9948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9949 
 
9950 
  def __eq__(self, other):
9951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9952 
 
9953 
  def __ne__(self, other):
9954 
    return not (self == other)
9955 
 
9956 
class getAllItems_result:
9957 
  """
9958 
  Attributes:
9959 
   - success
9960 
   - cex
9961 
  """
9962 
 
9963 
  thrift_spec = (
9964 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9965 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9966 
  )
9967 
 
9968 
  def __init__(self, success=None, cex=None,):
9969 
    self.success = success
9970 
    self.cex = cex
9971 
 
9972 
  def read(self, iprot):
9973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9975 
      return
9976 
    iprot.readStructBegin()
9977 
    while True:
9978 
      (fname, ftype, fid) = iprot.readFieldBegin()
9979 
      if ftype == TType.STOP:
9980 
        break
9981 
      if fid == 0:
9982 
        if ftype == TType.LIST:
9983 
          self.success = []
8590 kshitij.so 9984 
          (_etype63, _size60) = iprot.readListBegin()
9985 
          for _i64 in xrange(_size60):
9986 
            _elem65 = Item()
9987 
            _elem65.read(iprot)
9988 
            self.success.append(_elem65)
5944 mandeep.dh 9989 
          iprot.readListEnd()
9990 
        else:
9991 
          iprot.skip(ftype)
9992 
      elif fid == 1:
9993 
        if ftype == TType.STRUCT:
9994 
          self.cex = CatalogServiceException()
9995 
          self.cex.read(iprot)
9996 
        else:
9997 
          iprot.skip(ftype)
9998 
      else:
9999 
        iprot.skip(ftype)
10000 
      iprot.readFieldEnd()
10001 
    iprot.readStructEnd()
10002 
 
10003 
  def write(self, oprot):
10004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10006 
      return
10007 
    oprot.writeStructBegin('getAllItems_result')
10008 
    if self.success is not None:
10009 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10010 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10011 
      for iter66 in self.success:
10012 
        iter66.write(oprot)
5944 mandeep.dh 10013 
      oprot.writeListEnd()
10014 
      oprot.writeFieldEnd()
10015 
    if self.cex is not None:
10016 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10017 
      self.cex.write(oprot)
10018 
      oprot.writeFieldEnd()
10019 
    oprot.writeFieldStop()
10020 
    oprot.writeStructEnd()
10021 
 
10022 
  def validate(self):
10023 
    return
10024 
 
10025 
 
10026 
  def __repr__(self):
10027 
    L = ['%s=%r' % (key, value)
10028 
      for key, value in self.__dict__.iteritems()]
10029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10030 
 
10031 
  def __eq__(self, other):
10032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10033 
 
10034 
  def __ne__(self, other):
10035 
    return not (self == other)
10036 
 
10037 
class getAllItemsByStatus_args:
10038 
  """
10039 
  Attributes:
10040 
   - itemStatus
10041 
  """
10042 
 
10043 
  thrift_spec = (
10044 
    None, # 0
10045 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
10046 
  )
10047 
 
10048 
  def __init__(self, itemStatus=None,):
10049 
    self.itemStatus = itemStatus
10050 
 
10051 
  def read(self, iprot):
10052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10054 
      return
10055 
    iprot.readStructBegin()
10056 
    while True:
10057 
      (fname, ftype, fid) = iprot.readFieldBegin()
10058 
      if ftype == TType.STOP:
10059 
        break
10060 
      if fid == 1:
10061 
        if ftype == TType.I32:
10062 
          self.itemStatus = iprot.readI32();
10063 
        else:
10064 
          iprot.skip(ftype)
10065 
      else:
10066 
        iprot.skip(ftype)
10067 
      iprot.readFieldEnd()
10068 
    iprot.readStructEnd()
10069 
 
10070 
  def write(self, oprot):
10071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10073 
      return
10074 
    oprot.writeStructBegin('getAllItemsByStatus_args')
10075 
    if self.itemStatus is not None:
10076 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
10077 
      oprot.writeI32(self.itemStatus)
10078 
      oprot.writeFieldEnd()
10079 
    oprot.writeFieldStop()
10080 
    oprot.writeStructEnd()
10081 
 
10082 
  def validate(self):
10083 
    return
10084 
 
10085 
 
10086 
  def __repr__(self):
10087 
    L = ['%s=%r' % (key, value)
10088 
      for key, value in self.__dict__.iteritems()]
10089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10090 
 
10091 
  def __eq__(self, other):
10092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10093 
 
10094 
  def __ne__(self, other):
10095 
    return not (self == other)
10096 
 
10097 
class getAllItemsByStatus_result:
10098 
  """
10099 
  Attributes:
10100 
   - success
10101 
   - cex
10102 
  """
10103 
 
10104 
  thrift_spec = (
10105 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10106 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10107 
  )
10108 
 
10109 
  def __init__(self, success=None, cex=None,):
10110 
    self.success = success
10111 
    self.cex = cex
10112 
 
10113 
  def read(self, iprot):
10114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10116 
      return
10117 
    iprot.readStructBegin()
10118 
    while True:
10119 
      (fname, ftype, fid) = iprot.readFieldBegin()
10120 
      if ftype == TType.STOP:
10121 
        break
10122 
      if fid == 0:
10123 
        if ftype == TType.LIST:
10124 
          self.success = []
8590 kshitij.so 10125 
          (_etype70, _size67) = iprot.readListBegin()
10126 
          for _i71 in xrange(_size67):
10127 
            _elem72 = Item()
10128 
            _elem72.read(iprot)
10129 
            self.success.append(_elem72)
5944 mandeep.dh 10130 
          iprot.readListEnd()
10131 
        else:
10132 
          iprot.skip(ftype)
10133 
      elif fid == 1:
10134 
        if ftype == TType.STRUCT:
10135 
          self.cex = CatalogServiceException()
10136 
          self.cex.read(iprot)
10137 
        else:
10138 
          iprot.skip(ftype)
10139 
      else:
10140 
        iprot.skip(ftype)
10141 
      iprot.readFieldEnd()
10142 
    iprot.readStructEnd()
10143 
 
10144 
  def write(self, oprot):
10145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10147 
      return
10148 
    oprot.writeStructBegin('getAllItemsByStatus_result')
10149 
    if self.success is not None:
10150 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10151 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10152 
      for iter73 in self.success:
10153 
        iter73.write(oprot)
5944 mandeep.dh 10154 
      oprot.writeListEnd()
10155 
      oprot.writeFieldEnd()
10156 
    if self.cex is not None:
10157 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10158 
      self.cex.write(oprot)
10159 
      oprot.writeFieldEnd()
10160 
    oprot.writeFieldStop()
10161 
    oprot.writeStructEnd()
10162 
 
10163 
  def validate(self):
10164 
    return
10165 
 
10166 
 
10167 
  def __repr__(self):
10168 
    L = ['%s=%r' % (key, value)
10169 
      for key, value in self.__dict__.iteritems()]
10170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10171 
 
10172 
  def __eq__(self, other):
10173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10174 
 
10175 
  def __ne__(self, other):
10176 
    return not (self == other)
10177 
 
10178 
class markItemAsContentComplete_args:
10179 
  """
10180 
  Attributes:
10181 
   - entityId
10182 
   - category
10183 
   - brand
10184 
   - modelName
10185 
   - modelNumber
9253 rajveer 10186 
   - isAndroid
5944 mandeep.dh 10187 
  """
10188 
 
10189 
  thrift_spec = (
10190 
    None, # 0
10191 
    (1, TType.I64, 'entityId', None, None, ), # 1
10192 
    (2, TType.I64, 'category', None, None, ), # 2
10193 
    (3, TType.STRING, 'brand', None, None, ), # 3
10194 
    (4, TType.STRING, 'modelName', None, None, ), # 4
10195 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 10196 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 10197 
  )
10198 
 
9253 rajveer 10199 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 10200 
    self.entityId = entityId
10201 
    self.category = category
10202 
    self.brand = brand
10203 
    self.modelName = modelName
10204 
    self.modelNumber = modelNumber
9253 rajveer 10205 
    self.isAndroid = isAndroid
5944 mandeep.dh 10206 
 
10207 
  def read(self, iprot):
10208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10210 
      return
10211 
    iprot.readStructBegin()
10212 
    while True:
10213 
      (fname, ftype, fid) = iprot.readFieldBegin()
10214 
      if ftype == TType.STOP:
10215 
        break
10216 
      if fid == 1:
10217 
        if ftype == TType.I64:
10218 
          self.entityId = iprot.readI64();
10219 
        else:
10220 
          iprot.skip(ftype)
10221 
      elif fid == 2:
10222 
        if ftype == TType.I64:
10223 
          self.category = iprot.readI64();
10224 
        else:
10225 
          iprot.skip(ftype)
10226 
      elif fid == 3:
10227 
        if ftype == TType.STRING:
10228 
          self.brand = iprot.readString();
10229 
        else:
10230 
          iprot.skip(ftype)
10231 
      elif fid == 4:
10232 
        if ftype == TType.STRING:
10233 
          self.modelName = iprot.readString();
10234 
        else:
10235 
          iprot.skip(ftype)
10236 
      elif fid == 5:
10237 
        if ftype == TType.STRING:
10238 
          self.modelNumber = iprot.readString();
10239 
        else:
10240 
          iprot.skip(ftype)
9253 rajveer 10241 
      elif fid == 6:
10242 
        if ftype == TType.BOOL:
10243 
          self.isAndroid = iprot.readBool();
10244 
        else:
10245 
          iprot.skip(ftype)
5944 mandeep.dh 10246 
      else:
10247 
        iprot.skip(ftype)
10248 
      iprot.readFieldEnd()
10249 
    iprot.readStructEnd()
10250 
 
10251 
  def write(self, oprot):
10252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10254 
      return
10255 
    oprot.writeStructBegin('markItemAsContentComplete_args')
10256 
    if self.entityId is not None:
10257 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
10258 
      oprot.writeI64(self.entityId)
10259 
      oprot.writeFieldEnd()
10260 
    if self.category is not None:
10261 
      oprot.writeFieldBegin('category', TType.I64, 2)
10262 
      oprot.writeI64(self.category)
10263 
      oprot.writeFieldEnd()
10264 
    if self.brand is not None:
10265 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10266 
      oprot.writeString(self.brand)
10267 
      oprot.writeFieldEnd()
10268 
    if self.modelName is not None:
10269 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
10270 
      oprot.writeString(self.modelName)
10271 
      oprot.writeFieldEnd()
10272 
    if self.modelNumber is not None:
10273 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
10274 
      oprot.writeString(self.modelNumber)
10275 
      oprot.writeFieldEnd()
9253 rajveer 10276 
    if self.isAndroid is not None:
10277 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
10278 
      oprot.writeBool(self.isAndroid)
10279 
      oprot.writeFieldEnd()
5944 mandeep.dh 10280 
    oprot.writeFieldStop()
10281 
    oprot.writeStructEnd()
10282 
 
10283 
  def validate(self):
10284 
    return
10285 
 
10286 
 
10287 
  def __repr__(self):
10288 
    L = ['%s=%r' % (key, value)
10289 
      for key, value in self.__dict__.iteritems()]
10290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10291 
 
10292 
  def __eq__(self, other):
10293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10294 
 
10295 
  def __ne__(self, other):
10296 
    return not (self == other)
10297 
 
10298 
class markItemAsContentComplete_result:
10299 
  """
10300 
  Attributes:
10301 
   - success
10302 
   - cex
10303 
  """
10304 
 
10305 
  thrift_spec = (
10306 
    (0, TType.BOOL, 'success', None, None, ), # 0
10307 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10308 
  )
10309 
 
10310 
  def __init__(self, success=None, cex=None,):
10311 
    self.success = success
10312 
    self.cex = cex
10313 
 
10314 
  def read(self, iprot):
10315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10317 
      return
10318 
    iprot.readStructBegin()
10319 
    while True:
10320 
      (fname, ftype, fid) = iprot.readFieldBegin()
10321 
      if ftype == TType.STOP:
10322 
        break
10323 
      if fid == 0:
10324 
        if ftype == TType.BOOL:
10325 
          self.success = iprot.readBool();
10326 
        else:
10327 
          iprot.skip(ftype)
10328 
      elif fid == 1:
10329 
        if ftype == TType.STRUCT:
10330 
          self.cex = CatalogServiceException()
10331 
          self.cex.read(iprot)
10332 
        else:
10333 
          iprot.skip(ftype)
10334 
      else:
10335 
        iprot.skip(ftype)
10336 
      iprot.readFieldEnd()
10337 
    iprot.readStructEnd()
10338 
 
10339 
  def write(self, oprot):
10340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10342 
      return
10343 
    oprot.writeStructBegin('markItemAsContentComplete_result')
10344 
    if self.success is not None:
10345 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10346 
      oprot.writeBool(self.success)
10347 
      oprot.writeFieldEnd()
10348 
    if self.cex is not None:
10349 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10350 
      self.cex.write(oprot)
10351 
      oprot.writeFieldEnd()
10352 
    oprot.writeFieldStop()
10353 
    oprot.writeStructEnd()
10354 
 
10355 
  def validate(self):
10356 
    return
10357 
 
10358 
 
10359 
  def __repr__(self):
10360 
    L = ['%s=%r' % (key, value)
10361 
      for key, value in self.__dict__.iteritems()]
10362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10363 
 
10364 
  def __eq__(self, other):
10365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10366 
 
10367 
  def __ne__(self, other):
10368 
    return not (self == other)
10369 
 
10370 
class getAllItemsInRange_args:
10371 
  """
10372 
  Attributes:
10373 
   - offset
10374 
   - limit
10375 
  """
10376 
 
10377 
  thrift_spec = (
10378 
    None, # 0
10379 
    (1, TType.I64, 'offset', None, None, ), # 1
10380 
    (2, TType.I64, 'limit', None, None, ), # 2
10381 
  )
10382 
 
10383 
  def __init__(self, offset=None, limit=None,):
10384 
    self.offset = offset
10385 
    self.limit = limit
10386 
 
10387 
  def read(self, iprot):
10388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10390 
      return
10391 
    iprot.readStructBegin()
10392 
    while True:
10393 
      (fname, ftype, fid) = iprot.readFieldBegin()
10394 
      if ftype == TType.STOP:
10395 
        break
10396 
      if fid == 1:
10397 
        if ftype == TType.I64:
10398 
          self.offset = iprot.readI64();
10399 
        else:
10400 
          iprot.skip(ftype)
10401 
      elif fid == 2:
10402 
        if ftype == TType.I64:
10403 
          self.limit = iprot.readI64();
10404 
        else:
10405 
          iprot.skip(ftype)
10406 
      else:
10407 
        iprot.skip(ftype)
10408 
      iprot.readFieldEnd()
10409 
    iprot.readStructEnd()
10410 
 
10411 
  def write(self, oprot):
10412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10414 
      return
10415 
    oprot.writeStructBegin('getAllItemsInRange_args')
10416 
    if self.offset is not None:
10417 
      oprot.writeFieldBegin('offset', TType.I64, 1)
10418 
      oprot.writeI64(self.offset)
10419 
      oprot.writeFieldEnd()
10420 
    if self.limit is not None:
10421 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10422 
      oprot.writeI64(self.limit)
10423 
      oprot.writeFieldEnd()
10424 
    oprot.writeFieldStop()
10425 
    oprot.writeStructEnd()
10426 
 
10427 
  def validate(self):
10428 
    return
10429 
 
10430 
 
10431 
  def __repr__(self):
10432 
    L = ['%s=%r' % (key, value)
10433 
      for key, value in self.__dict__.iteritems()]
10434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10435 
 
10436 
  def __eq__(self, other):
10437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10438 
 
10439 
  def __ne__(self, other):
10440 
    return not (self == other)
10441 
 
10442 
class getAllItemsInRange_result:
10443 
  """
10444 
  Attributes:
10445 
   - success
10446 
   - cex
10447 
  """
10448 
 
10449 
  thrift_spec = (
10450 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10451 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10452 
  )
10453 
 
10454 
  def __init__(self, success=None, cex=None,):
10455 
    self.success = success
10456 
    self.cex = cex
10457 
 
10458 
  def read(self, iprot):
10459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10461 
      return
10462 
    iprot.readStructBegin()
10463 
    while True:
10464 
      (fname, ftype, fid) = iprot.readFieldBegin()
10465 
      if ftype == TType.STOP:
10466 
        break
10467 
      if fid == 0:
10468 
        if ftype == TType.LIST:
10469 
          self.success = []
8590 kshitij.so 10470 
          (_etype77, _size74) = iprot.readListBegin()
10471 
          for _i78 in xrange(_size74):
10472 
            _elem79 = Item()
10473 
            _elem79.read(iprot)
10474 
            self.success.append(_elem79)
5944 mandeep.dh 10475 
          iprot.readListEnd()
10476 
        else:
10477 
          iprot.skip(ftype)
10478 
      elif fid == 1:
10479 
        if ftype == TType.STRUCT:
10480 
          self.cex = CatalogServiceException()
10481 
          self.cex.read(iprot)
10482 
        else:
10483 
          iprot.skip(ftype)
10484 
      else:
10485 
        iprot.skip(ftype)
10486 
      iprot.readFieldEnd()
10487 
    iprot.readStructEnd()
10488 
 
10489 
  def write(self, oprot):
10490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10492 
      return
10493 
    oprot.writeStructBegin('getAllItemsInRange_result')
10494 
    if self.success is not None:
10495 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10496 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10497 
      for iter80 in self.success:
10498 
        iter80.write(oprot)
5944 mandeep.dh 10499 
      oprot.writeListEnd()
10500 
      oprot.writeFieldEnd()
10501 
    if self.cex is not None:
10502 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10503 
      self.cex.write(oprot)
10504 
      oprot.writeFieldEnd()
10505 
    oprot.writeFieldStop()
10506 
    oprot.writeStructEnd()
10507 
 
10508 
  def validate(self):
10509 
    return
10510 
 
10511 
 
10512 
  def __repr__(self):
10513 
    L = ['%s=%r' % (key, value)
10514 
      for key, value in self.__dict__.iteritems()]
10515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10516 
 
10517 
  def __eq__(self, other):
10518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10519 
 
10520 
  def __ne__(self, other):
10521 
    return not (self == other)
10522 
 
10523 
class getAllItemsByStatusInRange_args:
10524 
  """
10525 
  Attributes:
10526 
   - itemStatus
10527 
   - offset
10528 
   - limit
10529 
  """
10530 
 
10531 
  thrift_spec = (
10532 
    None, # 0
10533 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
10534 
    (2, TType.I64, 'offset', None, None, ), # 2
10535 
    (3, TType.I64, 'limit', None, None, ), # 3
10536 
  )
10537 
 
10538 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
10539 
    self.itemStatus = itemStatus
10540 
    self.offset = offset
10541 
    self.limit = limit
10542 
 
10543 
  def read(self, iprot):
10544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10546 
      return
10547 
    iprot.readStructBegin()
10548 
    while True:
10549 
      (fname, ftype, fid) = iprot.readFieldBegin()
10550 
      if ftype == TType.STOP:
10551 
        break
10552 
      if fid == 1:
10553 
        if ftype == TType.I32:
10554 
          self.itemStatus = iprot.readI32();
10555 
        else:
10556 
          iprot.skip(ftype)
10557 
      elif fid == 2:
10558 
        if ftype == TType.I64:
10559 
          self.offset = iprot.readI64();
10560 
        else:
10561 
          iprot.skip(ftype)
10562 
      elif fid == 3:
10563 
        if ftype == TType.I64:
10564 
          self.limit = iprot.readI64();
10565 
        else:
10566 
          iprot.skip(ftype)
10567 
      else:
10568 
        iprot.skip(ftype)
10569 
      iprot.readFieldEnd()
10570 
    iprot.readStructEnd()
10571 
 
10572 
  def write(self, oprot):
10573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10575 
      return
10576 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
10577 
    if self.itemStatus is not None:
10578 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
10579 
      oprot.writeI32(self.itemStatus)
10580 
      oprot.writeFieldEnd()
10581 
    if self.offset is not None:
10582 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10583 
      oprot.writeI64(self.offset)
10584 
      oprot.writeFieldEnd()
10585 
    if self.limit is not None:
10586 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10587 
      oprot.writeI64(self.limit)
10588 
      oprot.writeFieldEnd()
10589 
    oprot.writeFieldStop()
10590 
    oprot.writeStructEnd()
10591 
 
10592 
  def validate(self):
10593 
    return
10594 
 
10595 
 
10596 
  def __repr__(self):
10597 
    L = ['%s=%r' % (key, value)
10598 
      for key, value in self.__dict__.iteritems()]
10599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10600 
 
10601 
  def __eq__(self, other):
10602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10603 
 
10604 
  def __ne__(self, other):
10605 
    return not (self == other)
10606 
 
10607 
class getAllItemsByStatusInRange_result:
10608 
  """
10609 
  Attributes:
10610 
   - success
10611 
   - cex
10612 
  """
10613 
 
10614 
  thrift_spec = (
10615 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10616 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10617 
  )
10618 
 
10619 
  def __init__(self, success=None, cex=None,):
10620 
    self.success = success
10621 
    self.cex = cex
10622 
 
10623 
  def read(self, iprot):
10624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10626 
      return
10627 
    iprot.readStructBegin()
10628 
    while True:
10629 
      (fname, ftype, fid) = iprot.readFieldBegin()
10630 
      if ftype == TType.STOP:
10631 
        break
10632 
      if fid == 0:
10633 
        if ftype == TType.LIST:
10634 
          self.success = []
8590 kshitij.so 10635 
          (_etype84, _size81) = iprot.readListBegin()
10636 
          for _i85 in xrange(_size81):
10637 
            _elem86 = Item()
10638 
            _elem86.read(iprot)
10639 
            self.success.append(_elem86)
5944 mandeep.dh 10640 
          iprot.readListEnd()
10641 
        else:
10642 
          iprot.skip(ftype)
10643 
      elif fid == 1:
10644 
        if ftype == TType.STRUCT:
10645 
          self.cex = CatalogServiceException()
10646 
          self.cex.read(iprot)
10647 
        else:
10648 
          iprot.skip(ftype)
10649 
      else:
10650 
        iprot.skip(ftype)
10651 
      iprot.readFieldEnd()
10652 
    iprot.readStructEnd()
10653 
 
10654 
  def write(self, oprot):
10655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10657 
      return
10658 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
10659 
    if self.success is not None:
10660 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10661 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10662 
      for iter87 in self.success:
10663 
        iter87.write(oprot)
5944 mandeep.dh 10664 
      oprot.writeListEnd()
10665 
      oprot.writeFieldEnd()
10666 
    if self.cex is not None:
10667 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10668 
      self.cex.write(oprot)
10669 
      oprot.writeFieldEnd()
10670 
    oprot.writeFieldStop()
10671 
    oprot.writeStructEnd()
10672 
 
10673 
  def validate(self):
10674 
    return
10675 
 
10676 
 
10677 
  def __repr__(self):
10678 
    L = ['%s=%r' % (key, value)
10679 
      for key, value in self.__dict__.iteritems()]
10680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10681 
 
10682 
  def __eq__(self, other):
10683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10684 
 
10685 
  def __ne__(self, other):
10686 
    return not (self == other)
10687 
 
10688 
class getItemCountByStatus_args:
10689 
  """
10690 
  Attributes:
10691 
   - useStatus
10692 
   - itemStatus
10693 
  """
10694 
 
10695 
  thrift_spec = (
10696 
    None, # 0
10697 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
10698 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
10699 
  )
10700 
 
10701 
  def __init__(self, useStatus=None, itemStatus=None,):
10702 
    self.useStatus = useStatus
10703 
    self.itemStatus = itemStatus
10704 
 
10705 
  def read(self, iprot):
10706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10708 
      return
10709 
    iprot.readStructBegin()
10710 
    while True:
10711 
      (fname, ftype, fid) = iprot.readFieldBegin()
10712 
      if ftype == TType.STOP:
10713 
        break
10714 
      if fid == 1:
10715 
        if ftype == TType.BOOL:
10716 
          self.useStatus = iprot.readBool();
10717 
        else:
10718 
          iprot.skip(ftype)
10719 
      elif fid == 2:
10720 
        if ftype == TType.I32:
10721 
          self.itemStatus = iprot.readI32();
10722 
        else:
10723 
          iprot.skip(ftype)
10724 
      else:
10725 
        iprot.skip(ftype)
10726 
      iprot.readFieldEnd()
10727 
    iprot.readStructEnd()
10728 
 
10729 
  def write(self, oprot):
10730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10732 
      return
10733 
    oprot.writeStructBegin('getItemCountByStatus_args')
10734 
    if self.useStatus is not None:
10735 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
10736 
      oprot.writeBool(self.useStatus)
10737 
      oprot.writeFieldEnd()
10738 
    if self.itemStatus is not None:
10739 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
10740 
      oprot.writeI32(self.itemStatus)
10741 
      oprot.writeFieldEnd()
10742 
    oprot.writeFieldStop()
10743 
    oprot.writeStructEnd()
10744 
 
10745 
  def validate(self):
10746 
    return
10747 
 
10748 
 
10749 
  def __repr__(self):
10750 
    L = ['%s=%r' % (key, value)
10751 
      for key, value in self.__dict__.iteritems()]
10752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10753 
 
10754 
  def __eq__(self, other):
10755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10756 
 
10757 
  def __ne__(self, other):
10758 
    return not (self == other)
10759 
 
10760 
class getItemCountByStatus_result:
10761 
  """
10762 
  Attributes:
10763 
   - success
10764 
  """
10765 
 
10766 
  thrift_spec = (
10767 
    (0, TType.I32, 'success', None, None, ), # 0
10768 
  )
10769 
 
10770 
  def __init__(self, success=None,):
10771 
    self.success = success
10772 
 
10773 
  def read(self, iprot):
10774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10776 
      return
10777 
    iprot.readStructBegin()
10778 
    while True:
10779 
      (fname, ftype, fid) = iprot.readFieldBegin()
10780 
      if ftype == TType.STOP:
10781 
        break
10782 
      if fid == 0:
10783 
        if ftype == TType.I32:
10784 
          self.success = iprot.readI32();
10785 
        else:
10786 
          iprot.skip(ftype)
10787 
      else:
10788 
        iprot.skip(ftype)
10789 
      iprot.readFieldEnd()
10790 
    iprot.readStructEnd()
10791 
 
10792 
  def write(self, oprot):
10793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10795 
      return
10796 
    oprot.writeStructBegin('getItemCountByStatus_result')
10797 
    if self.success is not None:
10798 
      oprot.writeFieldBegin('success', TType.I32, 0)
10799 
      oprot.writeI32(self.success)
10800 
      oprot.writeFieldEnd()
10801 
    oprot.writeFieldStop()
10802 
    oprot.writeStructEnd()
10803 
 
10804 
  def validate(self):
10805 
    return
10806 
 
10807 
 
10808 
  def __repr__(self):
10809 
    L = ['%s=%r' % (key, value)
10810 
      for key, value in self.__dict__.iteritems()]
10811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10812 
 
10813 
  def __eq__(self, other):
10814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10815 
 
10816 
  def __ne__(self, other):
10817 
    return not (self == other)
10818 
 
10819 
class getBestSellers_args:
10820 
 
10821 
  thrift_spec = (
10822 
  )
10823 
 
10824 
  def read(self, iprot):
10825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10827 
      return
10828 
    iprot.readStructBegin()
10829 
    while True:
10830 
      (fname, ftype, fid) = iprot.readFieldBegin()
10831 
      if ftype == TType.STOP:
10832 
        break
10833 
      else:
10834 
        iprot.skip(ftype)
10835 
      iprot.readFieldEnd()
10836 
    iprot.readStructEnd()
10837 
 
10838 
  def write(self, oprot):
10839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10841 
      return
10842 
    oprot.writeStructBegin('getBestSellers_args')
10843 
    oprot.writeFieldStop()
10844 
    oprot.writeStructEnd()
10845 
 
10846 
  def validate(self):
10847 
    return
10848 
 
10849 
 
10850 
  def __repr__(self):
10851 
    L = ['%s=%r' % (key, value)
10852 
      for key, value in self.__dict__.iteritems()]
10853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10854 
 
10855 
  def __eq__(self, other):
10856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10857 
 
10858 
  def __ne__(self, other):
10859 
    return not (self == other)
10860 
 
10861 
class getBestSellers_result:
10862 
  """
10863 
  Attributes:
10864 
   - success
10865 
   - isex
10866 
  """
10867 
 
10868 
  thrift_spec = (
10869 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10870 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10871 
  )
10872 
 
10873 
  def __init__(self, success=None, isex=None,):
10874 
    self.success = success
10875 
    self.isex = isex
10876 
 
10877 
  def read(self, iprot):
10878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10880 
      return
10881 
    iprot.readStructBegin()
10882 
    while True:
10883 
      (fname, ftype, fid) = iprot.readFieldBegin()
10884 
      if ftype == TType.STOP:
10885 
        break
10886 
      if fid == 0:
10887 
        if ftype == TType.LIST:
10888 
          self.success = []
8590 kshitij.so 10889 
          (_etype91, _size88) = iprot.readListBegin()
10890 
          for _i92 in xrange(_size88):
10891 
            _elem93 = Item()
10892 
            _elem93.read(iprot)
10893 
            self.success.append(_elem93)
5944 mandeep.dh 10894 
          iprot.readListEnd()
10895 
        else:
10896 
          iprot.skip(ftype)
10897 
      elif fid == 1:
10898 
        if ftype == TType.STRUCT:
10899 
          self.isex = CatalogServiceException()
10900 
          self.isex.read(iprot)
10901 
        else:
10902 
          iprot.skip(ftype)
10903 
      else:
10904 
        iprot.skip(ftype)
10905 
      iprot.readFieldEnd()
10906 
    iprot.readStructEnd()
10907 
 
10908 
  def write(self, oprot):
10909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10911 
      return
10912 
    oprot.writeStructBegin('getBestSellers_result')
10913 
    if self.success is not None:
10914 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10915 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10916 
      for iter94 in self.success:
10917 
        iter94.write(oprot)
5944 mandeep.dh 10918 
      oprot.writeListEnd()
10919 
      oprot.writeFieldEnd()
10920 
    if self.isex is not None:
10921 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10922 
      self.isex.write(oprot)
10923 
      oprot.writeFieldEnd()
10924 
    oprot.writeFieldStop()
10925 
    oprot.writeStructEnd()
10926 
 
10927 
  def validate(self):
10928 
    return
10929 
 
10930 
 
10931 
  def __repr__(self):
10932 
    L = ['%s=%r' % (key, value)
10933 
      for key, value in self.__dict__.iteritems()]
10934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10935 
 
10936 
  def __eq__(self, other):
10937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10938 
 
10939 
  def __ne__(self, other):
10940 
    return not (self == other)
10941 
 
10942 
class getBestSellersCatalogIds_args:
10943 
  """
10944 
  Attributes:
10945 
   - beginIndex
10946 
   - totalItems
10947 
   - brand
10948 
   - category
10949 
  """
10950 
 
10951 
  thrift_spec = (
10952 
    None, # 0
10953 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10954 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10955 
    (3, TType.STRING, 'brand', None, None, ), # 3
10956 
    (4, TType.I64, 'category', None, None, ), # 4
10957 
  )
10958 
 
10959 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10960 
    self.beginIndex = beginIndex
10961 
    self.totalItems = totalItems
10962 
    self.brand = brand
10963 
    self.category = category
10964 
 
10965 
  def read(self, iprot):
10966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10968 
      return
10969 
    iprot.readStructBegin()
10970 
    while True:
10971 
      (fname, ftype, fid) = iprot.readFieldBegin()
10972 
      if ftype == TType.STOP:
10973 
        break
10974 
      if fid == 1:
10975 
        if ftype == TType.I64:
10976 
          self.beginIndex = iprot.readI64();
10977 
        else:
10978 
          iprot.skip(ftype)
10979 
      elif fid == 2:
10980 
        if ftype == TType.I64:
10981 
          self.totalItems = iprot.readI64();
10982 
        else:
10983 
          iprot.skip(ftype)
10984 
      elif fid == 3:
10985 
        if ftype == TType.STRING:
10986 
          self.brand = iprot.readString();
10987 
        else:
10988 
          iprot.skip(ftype)
10989 
      elif fid == 4:
10990 
        if ftype == TType.I64:
10991 
          self.category = iprot.readI64();
10992 
        else:
10993 
          iprot.skip(ftype)
10994 
      else:
10995 
        iprot.skip(ftype)
10996 
      iprot.readFieldEnd()
10997 
    iprot.readStructEnd()
10998 
 
10999 
  def write(self, oprot):
11000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11002 
      return
11003 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
11004 
    if self.beginIndex is not None:
11005 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11006 
      oprot.writeI64(self.beginIndex)
11007 
      oprot.writeFieldEnd()
11008 
    if self.totalItems is not None:
11009 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11010 
      oprot.writeI64(self.totalItems)
11011 
      oprot.writeFieldEnd()
11012 
    if self.brand is not None:
11013 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11014 
      oprot.writeString(self.brand)
11015 
      oprot.writeFieldEnd()
11016 
    if self.category is not None:
11017 
      oprot.writeFieldBegin('category', TType.I64, 4)
11018 
      oprot.writeI64(self.category)
11019 
      oprot.writeFieldEnd()
11020 
    oprot.writeFieldStop()
11021 
    oprot.writeStructEnd()
11022 
 
11023 
  def validate(self):
11024 
    return
11025 
 
11026 
 
11027 
  def __repr__(self):
11028 
    L = ['%s=%r' % (key, value)
11029 
      for key, value in self.__dict__.iteritems()]
11030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11031 
 
11032 
  def __eq__(self, other):
11033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11034 
 
11035 
  def __ne__(self, other):
11036 
    return not (self == other)
11037 
 
11038 
class getBestSellersCatalogIds_result:
11039 
  """
11040 
  Attributes:
11041 
   - success
11042 
   - cex
11043 
  """
11044 
 
11045 
  thrift_spec = (
11046 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11047 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11048 
  )
11049 
 
11050 
  def __init__(self, success=None, cex=None,):
11051 
    self.success = success
11052 
    self.cex = cex
11053 
 
11054 
  def read(self, iprot):
11055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11057 
      return
11058 
    iprot.readStructBegin()
11059 
    while True:
11060 
      (fname, ftype, fid) = iprot.readFieldBegin()
11061 
      if ftype == TType.STOP:
11062 
        break
11063 
      if fid == 0:
11064 
        if ftype == TType.LIST:
11065 
          self.success = []
8590 kshitij.so 11066 
          (_etype98, _size95) = iprot.readListBegin()
11067 
          for _i99 in xrange(_size95):
11068 
            _elem100 = iprot.readI64();
11069 
            self.success.append(_elem100)
5944 mandeep.dh 11070 
          iprot.readListEnd()
11071 
        else:
11072 
          iprot.skip(ftype)
11073 
      elif fid == 1:
11074 
        if ftype == TType.STRUCT:
11075 
          self.cex = CatalogServiceException()
11076 
          self.cex.read(iprot)
11077 
        else:
11078 
          iprot.skip(ftype)
11079 
      else:
11080 
        iprot.skip(ftype)
11081 
      iprot.readFieldEnd()
11082 
    iprot.readStructEnd()
11083 
 
11084 
  def write(self, oprot):
11085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11087 
      return
11088 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
11089 
    if self.success is not None:
11090 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11091 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11092 
      for iter101 in self.success:
11093 
        oprot.writeI64(iter101)
5944 mandeep.dh 11094 
      oprot.writeListEnd()
11095 
      oprot.writeFieldEnd()
11096 
    if self.cex is not None:
11097 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11098 
      self.cex.write(oprot)
11099 
      oprot.writeFieldEnd()
11100 
    oprot.writeFieldStop()
11101 
    oprot.writeStructEnd()
11102 
 
11103 
  def validate(self):
11104 
    return
11105 
 
11106 
 
11107 
  def __repr__(self):
11108 
    L = ['%s=%r' % (key, value)
11109 
      for key, value in self.__dict__.iteritems()]
11110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11111 
 
11112 
  def __eq__(self, other):
11113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11114 
 
11115 
  def __ne__(self, other):
11116 
    return not (self == other)
11117 
 
11118 
class getBestSellersCount_args:
11119 
 
11120 
  thrift_spec = (
11121 
  )
11122 
 
11123 
  def read(self, iprot):
11124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11126 
      return
11127 
    iprot.readStructBegin()
11128 
    while True:
11129 
      (fname, ftype, fid) = iprot.readFieldBegin()
11130 
      if ftype == TType.STOP:
11131 
        break
11132 
      else:
11133 
        iprot.skip(ftype)
11134 
      iprot.readFieldEnd()
11135 
    iprot.readStructEnd()
11136 
 
11137 
  def write(self, oprot):
11138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11140 
      return
11141 
    oprot.writeStructBegin('getBestSellersCount_args')
11142 
    oprot.writeFieldStop()
11143 
    oprot.writeStructEnd()
11144 
 
11145 
  def validate(self):
11146 
    return
11147 
 
11148 
 
11149 
  def __repr__(self):
11150 
    L = ['%s=%r' % (key, value)
11151 
      for key, value in self.__dict__.iteritems()]
11152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11153 
 
11154 
  def __eq__(self, other):
11155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11156 
 
11157 
  def __ne__(self, other):
11158 
    return not (self == other)
11159 
 
11160 
class getBestSellersCount_result:
11161 
  """
11162 
  Attributes:
11163 
   - success
11164 
   - cex
11165 
  """
11166 
 
11167 
  thrift_spec = (
11168 
    (0, TType.I64, 'success', None, None, ), # 0
11169 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11170 
  )
11171 
 
11172 
  def __init__(self, success=None, cex=None,):
11173 
    self.success = success
11174 
    self.cex = cex
11175 
 
11176 
  def read(self, iprot):
11177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11179 
      return
11180 
    iprot.readStructBegin()
11181 
    while True:
11182 
      (fname, ftype, fid) = iprot.readFieldBegin()
11183 
      if ftype == TType.STOP:
11184 
        break
11185 
      if fid == 0:
11186 
        if ftype == TType.I64:
11187 
          self.success = iprot.readI64();
11188 
        else:
11189 
          iprot.skip(ftype)
11190 
      elif fid == 1:
11191 
        if ftype == TType.STRUCT:
11192 
          self.cex = CatalogServiceException()
11193 
          self.cex.read(iprot)
11194 
        else:
11195 
          iprot.skip(ftype)
11196 
      else:
11197 
        iprot.skip(ftype)
11198 
      iprot.readFieldEnd()
11199 
    iprot.readStructEnd()
11200 
 
11201 
  def write(self, oprot):
11202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11204 
      return
11205 
    oprot.writeStructBegin('getBestSellersCount_result')
11206 
    if self.success is not None:
11207 
      oprot.writeFieldBegin('success', TType.I64, 0)
11208 
      oprot.writeI64(self.success)
11209 
      oprot.writeFieldEnd()
11210 
    if self.cex is not None:
11211 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11212 
      self.cex.write(oprot)
11213 
      oprot.writeFieldEnd()
11214 
    oprot.writeFieldStop()
11215 
    oprot.writeStructEnd()
11216 
 
11217 
  def validate(self):
11218 
    return
11219 
 
11220 
 
11221 
  def __repr__(self):
11222 
    L = ['%s=%r' % (key, value)
11223 
      for key, value in self.__dict__.iteritems()]
11224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11225 
 
11226 
  def __eq__(self, other):
11227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11228 
 
11229 
  def __ne__(self, other):
11230 
    return not (self == other)
11231 
 
11232 
class getBestDeals_args:
11233 
 
11234 
  thrift_spec = (
11235 
  )
11236 
 
11237 
  def read(self, iprot):
11238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11240 
      return
11241 
    iprot.readStructBegin()
11242 
    while True:
11243 
      (fname, ftype, fid) = iprot.readFieldBegin()
11244 
      if ftype == TType.STOP:
11245 
        break
11246 
      else:
11247 
        iprot.skip(ftype)
11248 
      iprot.readFieldEnd()
11249 
    iprot.readStructEnd()
11250 
 
11251 
  def write(self, oprot):
11252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11254 
      return
11255 
    oprot.writeStructBegin('getBestDeals_args')
11256 
    oprot.writeFieldStop()
11257 
    oprot.writeStructEnd()
11258 
 
11259 
  def validate(self):
11260 
    return
11261 
 
11262 
 
11263 
  def __repr__(self):
11264 
    L = ['%s=%r' % (key, value)
11265 
      for key, value in self.__dict__.iteritems()]
11266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11267 
 
11268 
  def __eq__(self, other):
11269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11270 
 
11271 
  def __ne__(self, other):
11272 
    return not (self == other)
11273 
 
11274 
class getBestDeals_result:
11275 
  """
11276 
  Attributes:
11277 
   - success
11278 
   - isex
11279 
  """
11280 
 
11281 
  thrift_spec = (
11282 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11283 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11284 
  )
11285 
 
11286 
  def __init__(self, success=None, isex=None,):
11287 
    self.success = success
11288 
    self.isex = isex
11289 
 
11290 
  def read(self, iprot):
11291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11293 
      return
11294 
    iprot.readStructBegin()
11295 
    while True:
11296 
      (fname, ftype, fid) = iprot.readFieldBegin()
11297 
      if ftype == TType.STOP:
11298 
        break
11299 
      if fid == 0:
11300 
        if ftype == TType.LIST:
11301 
          self.success = []
8590 kshitij.so 11302 
          (_etype105, _size102) = iprot.readListBegin()
11303 
          for _i106 in xrange(_size102):
11304 
            _elem107 = Item()
11305 
            _elem107.read(iprot)
11306 
            self.success.append(_elem107)
5944 mandeep.dh 11307 
          iprot.readListEnd()
11308 
        else:
11309 
          iprot.skip(ftype)
11310 
      elif fid == 1:
11311 
        if ftype == TType.STRUCT:
11312 
          self.isex = CatalogServiceException()
11313 
          self.isex.read(iprot)
11314 
        else:
11315 
          iprot.skip(ftype)
11316 
      else:
11317 
        iprot.skip(ftype)
11318 
      iprot.readFieldEnd()
11319 
    iprot.readStructEnd()
11320 
 
11321 
  def write(self, oprot):
11322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11324 
      return
11325 
    oprot.writeStructBegin('getBestDeals_result')
11326 
    if self.success is not None:
11327 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11328 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11329 
      for iter108 in self.success:
11330 
        iter108.write(oprot)
5944 mandeep.dh 11331 
      oprot.writeListEnd()
11332 
      oprot.writeFieldEnd()
11333 
    if self.isex is not None:
11334 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11335 
      self.isex.write(oprot)
11336 
      oprot.writeFieldEnd()
11337 
    oprot.writeFieldStop()
11338 
    oprot.writeStructEnd()
11339 
 
11340 
  def validate(self):
11341 
    return
11342 
 
11343 
 
11344 
  def __repr__(self):
11345 
    L = ['%s=%r' % (key, value)
11346 
      for key, value in self.__dict__.iteritems()]
11347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11348 
 
11349 
  def __eq__(self, other):
11350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11351 
 
11352 
  def __ne__(self, other):
11353 
    return not (self == other)
11354 
 
11355 
class getBestDealsCatalogIds_args:
11356 
  """
11357 
  Attributes:
11358 
   - beginIndex
11359 
   - totalItems
11360 
   - brand
11361 
   - category
11362 
  """
11363 
 
11364 
  thrift_spec = (
11365 
    None, # 0
11366 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11367 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11368 
    (3, TType.STRING, 'brand', None, None, ), # 3
11369 
    (4, TType.I64, 'category', None, None, ), # 4
11370 
  )
11371 
 
11372 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
11373 
    self.beginIndex = beginIndex
11374 
    self.totalItems = totalItems
11375 
    self.brand = brand
11376 
    self.category = category
11377 
 
11378 
  def read(self, iprot):
11379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11381 
      return
11382 
    iprot.readStructBegin()
11383 
    while True:
11384 
      (fname, ftype, fid) = iprot.readFieldBegin()
11385 
      if ftype == TType.STOP:
11386 
        break
11387 
      if fid == 1:
11388 
        if ftype == TType.I64:
11389 
          self.beginIndex = iprot.readI64();
11390 
        else:
11391 
          iprot.skip(ftype)
11392 
      elif fid == 2:
11393 
        if ftype == TType.I64:
11394 
          self.totalItems = iprot.readI64();
11395 
        else:
11396 
          iprot.skip(ftype)
11397 
      elif fid == 3:
11398 
        if ftype == TType.STRING:
11399 
          self.brand = iprot.readString();
11400 
        else:
11401 
          iprot.skip(ftype)
11402 
      elif fid == 4:
11403 
        if ftype == TType.I64:
11404 
          self.category = iprot.readI64();
11405 
        else:
11406 
          iprot.skip(ftype)
11407 
      else:
11408 
        iprot.skip(ftype)
11409 
      iprot.readFieldEnd()
11410 
    iprot.readStructEnd()
11411 
 
11412 
  def write(self, oprot):
11413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11415 
      return
11416 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
11417 
    if self.beginIndex is not None:
11418 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11419 
      oprot.writeI64(self.beginIndex)
11420 
      oprot.writeFieldEnd()
11421 
    if self.totalItems is not None:
11422 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11423 
      oprot.writeI64(self.totalItems)
11424 
      oprot.writeFieldEnd()
11425 
    if self.brand is not None:
11426 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11427 
      oprot.writeString(self.brand)
11428 
      oprot.writeFieldEnd()
11429 
    if self.category is not None:
11430 
      oprot.writeFieldBegin('category', TType.I64, 4)
11431 
      oprot.writeI64(self.category)
11432 
      oprot.writeFieldEnd()
11433 
    oprot.writeFieldStop()
11434 
    oprot.writeStructEnd()
11435 
 
11436 
  def validate(self):
11437 
    return
11438 
 
11439 
 
11440 
  def __repr__(self):
11441 
    L = ['%s=%r' % (key, value)
11442 
      for key, value in self.__dict__.iteritems()]
11443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11444 
 
11445 
  def __eq__(self, other):
11446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11447 
 
11448 
  def __ne__(self, other):
11449 
    return not (self == other)
11450 
 
11451 
class getBestDealsCatalogIds_result:
11452 
  """
11453 
  Attributes:
11454 
   - success
11455 
   - cex
11456 
  """
11457 
 
11458 
  thrift_spec = (
11459 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11460 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11461 
  )
11462 
 
11463 
  def __init__(self, success=None, cex=None,):
11464 
    self.success = success
11465 
    self.cex = cex
11466 
 
11467 
  def read(self, iprot):
11468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11470 
      return
11471 
    iprot.readStructBegin()
11472 
    while True:
11473 
      (fname, ftype, fid) = iprot.readFieldBegin()
11474 
      if ftype == TType.STOP:
11475 
        break
11476 
      if fid == 0:
11477 
        if ftype == TType.LIST:
11478 
          self.success = []
8590 kshitij.so 11479 
          (_etype112, _size109) = iprot.readListBegin()
11480 
          for _i113 in xrange(_size109):
11481 
            _elem114 = iprot.readI64();
11482 
            self.success.append(_elem114)
5944 mandeep.dh 11483 
          iprot.readListEnd()
11484 
        else:
11485 
          iprot.skip(ftype)
11486 
      elif fid == 1:
11487 
        if ftype == TType.STRUCT:
11488 
          self.cex = CatalogServiceException()
11489 
          self.cex.read(iprot)
11490 
        else:
11491 
          iprot.skip(ftype)
11492 
      else:
11493 
        iprot.skip(ftype)
11494 
      iprot.readFieldEnd()
11495 
    iprot.readStructEnd()
11496 
 
11497 
  def write(self, oprot):
11498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11500 
      return
11501 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
11502 
    if self.success is not None:
11503 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11504 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11505 
      for iter115 in self.success:
11506 
        oprot.writeI64(iter115)
5944 mandeep.dh 11507 
      oprot.writeListEnd()
11508 
      oprot.writeFieldEnd()
11509 
    if self.cex is not None:
11510 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11511 
      self.cex.write(oprot)
11512 
      oprot.writeFieldEnd()
11513 
    oprot.writeFieldStop()
11514 
    oprot.writeStructEnd()
11515 
 
11516 
  def validate(self):
11517 
    return
11518 
 
11519 
 
11520 
  def __repr__(self):
11521 
    L = ['%s=%r' % (key, value)
11522 
      for key, value in self.__dict__.iteritems()]
11523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11524 
 
11525 
  def __eq__(self, other):
11526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11527 
 
11528 
  def __ne__(self, other):
11529 
    return not (self == other)
11530 
 
11531 
class getBestDealsCount_args:
11532 
 
11533 
  thrift_spec = (
11534 
  )
11535 
 
11536 
  def read(self, iprot):
11537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11539 
      return
11540 
    iprot.readStructBegin()
11541 
    while True:
11542 
      (fname, ftype, fid) = iprot.readFieldBegin()
11543 
      if ftype == TType.STOP:
11544 
        break
11545 
      else:
11546 
        iprot.skip(ftype)
11547 
      iprot.readFieldEnd()
11548 
    iprot.readStructEnd()
11549 
 
11550 
  def write(self, oprot):
11551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11553 
      return
11554 
    oprot.writeStructBegin('getBestDealsCount_args')
11555 
    oprot.writeFieldStop()
11556 
    oprot.writeStructEnd()
11557 
 
11558 
  def validate(self):
11559 
    return
11560 
 
11561 
 
11562 
  def __repr__(self):
11563 
    L = ['%s=%r' % (key, value)
11564 
      for key, value in self.__dict__.iteritems()]
11565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11566 
 
11567 
  def __eq__(self, other):
11568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11569 
 
11570 
  def __ne__(self, other):
11571 
    return not (self == other)
11572 
 
11573 
class getBestDealsCount_result:
11574 
  """
11575 
  Attributes:
11576 
   - success
11577 
   - cex
11578 
  """
11579 
 
11580 
  thrift_spec = (
11581 
    (0, TType.I64, 'success', None, None, ), # 0
11582 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11583 
  )
11584 
 
11585 
  def __init__(self, success=None, cex=None,):
11586 
    self.success = success
11587 
    self.cex = cex
11588 
 
11589 
  def read(self, iprot):
11590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11592 
      return
11593 
    iprot.readStructBegin()
11594 
    while True:
11595 
      (fname, ftype, fid) = iprot.readFieldBegin()
11596 
      if ftype == TType.STOP:
11597 
        break
11598 
      if fid == 0:
11599 
        if ftype == TType.I64:
11600 
          self.success = iprot.readI64();
11601 
        else:
11602 
          iprot.skip(ftype)
11603 
      elif fid == 1:
11604 
        if ftype == TType.STRUCT:
11605 
          self.cex = CatalogServiceException()
11606 
          self.cex.read(iprot)
11607 
        else:
11608 
          iprot.skip(ftype)
11609 
      else:
11610 
        iprot.skip(ftype)
11611 
      iprot.readFieldEnd()
11612 
    iprot.readStructEnd()
11613 
 
11614 
  def write(self, oprot):
11615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11617 
      return
11618 
    oprot.writeStructBegin('getBestDealsCount_result')
11619 
    if self.success is not None:
11620 
      oprot.writeFieldBegin('success', TType.I64, 0)
11621 
      oprot.writeI64(self.success)
11622 
      oprot.writeFieldEnd()
11623 
    if self.cex is not None:
11624 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11625 
      self.cex.write(oprot)
11626 
      oprot.writeFieldEnd()
11627 
    oprot.writeFieldStop()
11628 
    oprot.writeStructEnd()
11629 
 
11630 
  def validate(self):
11631 
    return
11632 
 
11633 
 
11634 
  def __repr__(self):
11635 
    L = ['%s=%r' % (key, value)
11636 
      for key, value in self.__dict__.iteritems()]
11637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11638 
 
11639 
  def __eq__(self, other):
11640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11641 
 
11642 
  def __ne__(self, other):
11643 
    return not (self == other)
11644 
 
11645 
class getComingSoon_args:
11646 
 
11647 
  thrift_spec = (
11648 
  )
11649 
 
11650 
  def read(self, iprot):
11651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11653 
      return
11654 
    iprot.readStructBegin()
11655 
    while True:
11656 
      (fname, ftype, fid) = iprot.readFieldBegin()
11657 
      if ftype == TType.STOP:
11658 
        break
11659 
      else:
11660 
        iprot.skip(ftype)
11661 
      iprot.readFieldEnd()
11662 
    iprot.readStructEnd()
11663 
 
11664 
  def write(self, oprot):
11665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11667 
      return
11668 
    oprot.writeStructBegin('getComingSoon_args')
11669 
    oprot.writeFieldStop()
11670 
    oprot.writeStructEnd()
11671 
 
11672 
  def validate(self):
11673 
    return
11674 
 
11675 
 
11676 
  def __repr__(self):
11677 
    L = ['%s=%r' % (key, value)
11678 
      for key, value in self.__dict__.iteritems()]
11679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11680 
 
11681 
  def __eq__(self, other):
11682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11683 
 
11684 
  def __ne__(self, other):
11685 
    return not (self == other)
11686 
 
11687 
class getComingSoon_result:
11688 
  """
11689 
  Attributes:
11690 
   - success
11691 
   - isex
11692 
  """
11693 
 
11694 
  thrift_spec = (
11695 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11696 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11697 
  )
11698 
 
11699 
  def __init__(self, success=None, isex=None,):
11700 
    self.success = success
11701 
    self.isex = isex
11702 
 
11703 
  def read(self, iprot):
11704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11706 
      return
11707 
    iprot.readStructBegin()
11708 
    while True:
11709 
      (fname, ftype, fid) = iprot.readFieldBegin()
11710 
      if ftype == TType.STOP:
11711 
        break
11712 
      if fid == 0:
11713 
        if ftype == TType.LIST:
11714 
          self.success = []
8590 kshitij.so 11715 
          (_etype119, _size116) = iprot.readListBegin()
11716 
          for _i120 in xrange(_size116):
11717 
            _elem121 = Item()
11718 
            _elem121.read(iprot)
11719 
            self.success.append(_elem121)
5944 mandeep.dh 11720 
          iprot.readListEnd()
11721 
        else:
11722 
          iprot.skip(ftype)
11723 
      elif fid == 1:
11724 
        if ftype == TType.STRUCT:
11725 
          self.isex = CatalogServiceException()
11726 
          self.isex.read(iprot)
11727 
        else:
11728 
          iprot.skip(ftype)
11729 
      else:
11730 
        iprot.skip(ftype)
11731 
      iprot.readFieldEnd()
11732 
    iprot.readStructEnd()
11733 
 
11734 
  def write(self, oprot):
11735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11737 
      return
11738 
    oprot.writeStructBegin('getComingSoon_result')
11739 
    if self.success is not None:
11740 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11741 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11742 
      for iter122 in self.success:
11743 
        iter122.write(oprot)
5944 mandeep.dh 11744 
      oprot.writeListEnd()
11745 
      oprot.writeFieldEnd()
11746 
    if self.isex is not None:
11747 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11748 
      self.isex.write(oprot)
11749 
      oprot.writeFieldEnd()
11750 
    oprot.writeFieldStop()
11751 
    oprot.writeStructEnd()
11752 
 
11753 
  def validate(self):
11754 
    return
11755 
 
11756 
 
11757 
  def __repr__(self):
11758 
    L = ['%s=%r' % (key, value)
11759 
      for key, value in self.__dict__.iteritems()]
11760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11761 
 
11762 
  def __eq__(self, other):
11763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11764 
 
11765 
  def __ne__(self, other):
11766 
    return not (self == other)
11767 
 
11768 
class getComingSoonCatalogIds_args:
11769 
  """
11770 
  Attributes:
11771 
   - beginIndex
11772 
   - totalItems
11773 
   - brand
11774 
   - category
11775 
  """
11776 
 
11777 
  thrift_spec = (
11778 
    None, # 0
11779 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11780 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11781 
    (3, TType.STRING, 'brand', None, None, ), # 3
11782 
    (4, TType.I64, 'category', None, None, ), # 4
11783 
  )
11784 
 
11785 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
11786 
    self.beginIndex = beginIndex
11787 
    self.totalItems = totalItems
11788 
    self.brand = brand
11789 
    self.category = category
11790 
 
11791 
  def read(self, iprot):
11792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11794 
      return
11795 
    iprot.readStructBegin()
11796 
    while True:
11797 
      (fname, ftype, fid) = iprot.readFieldBegin()
11798 
      if ftype == TType.STOP:
11799 
        break
11800 
      if fid == 1:
11801 
        if ftype == TType.I64:
11802 
          self.beginIndex = iprot.readI64();
11803 
        else:
11804 
          iprot.skip(ftype)
11805 
      elif fid == 2:
11806 
        if ftype == TType.I64:
11807 
          self.totalItems = iprot.readI64();
11808 
        else:
11809 
          iprot.skip(ftype)
11810 
      elif fid == 3:
11811 
        if ftype == TType.STRING:
11812 
          self.brand = iprot.readString();
11813 
        else:
11814 
          iprot.skip(ftype)
11815 
      elif fid == 4:
11816 
        if ftype == TType.I64:
11817 
          self.category = iprot.readI64();
11818 
        else:
11819 
          iprot.skip(ftype)
11820 
      else:
11821 
        iprot.skip(ftype)
11822 
      iprot.readFieldEnd()
11823 
    iprot.readStructEnd()
11824 
 
11825 
  def write(self, oprot):
11826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11828 
      return
11829 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
11830 
    if self.beginIndex is not None:
11831 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11832 
      oprot.writeI64(self.beginIndex)
11833 
      oprot.writeFieldEnd()
11834 
    if self.totalItems is not None:
11835 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11836 
      oprot.writeI64(self.totalItems)
11837 
      oprot.writeFieldEnd()
11838 
    if self.brand is not None:
11839 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11840 
      oprot.writeString(self.brand)
11841 
      oprot.writeFieldEnd()
11842 
    if self.category is not None:
11843 
      oprot.writeFieldBegin('category', TType.I64, 4)
11844 
      oprot.writeI64(self.category)
11845 
      oprot.writeFieldEnd()
11846 
    oprot.writeFieldStop()
11847 
    oprot.writeStructEnd()
11848 
 
11849 
  def validate(self):
11850 
    return
11851 
 
11852 
 
11853 
  def __repr__(self):
11854 
    L = ['%s=%r' % (key, value)
11855 
      for key, value in self.__dict__.iteritems()]
11856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11857 
 
11858 
  def __eq__(self, other):
11859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11860 
 
11861 
  def __ne__(self, other):
11862 
    return not (self == other)
11863 
 
11864 
class getComingSoonCatalogIds_result:
11865 
  """
11866 
  Attributes:
11867 
   - success
11868 
   - cex
11869 
  """
11870 
 
11871 
  thrift_spec = (
11872 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11873 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11874 
  )
11875 
 
11876 
  def __init__(self, success=None, cex=None,):
11877 
    self.success = success
11878 
    self.cex = cex
11879 
 
11880 
  def read(self, iprot):
11881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11883 
      return
11884 
    iprot.readStructBegin()
11885 
    while True:
11886 
      (fname, ftype, fid) = iprot.readFieldBegin()
11887 
      if ftype == TType.STOP:
11888 
        break
11889 
      if fid == 0:
11890 
        if ftype == TType.LIST:
11891 
          self.success = []
8590 kshitij.so 11892 
          (_etype126, _size123) = iprot.readListBegin()
11893 
          for _i127 in xrange(_size123):
11894 
            _elem128 = iprot.readI64();
11895 
            self.success.append(_elem128)
5944 mandeep.dh 11896 
          iprot.readListEnd()
11897 
        else:
11898 
          iprot.skip(ftype)
11899 
      elif fid == 1:
11900 
        if ftype == TType.STRUCT:
11901 
          self.cex = CatalogServiceException()
11902 
          self.cex.read(iprot)
11903 
        else:
11904 
          iprot.skip(ftype)
11905 
      else:
11906 
        iprot.skip(ftype)
11907 
      iprot.readFieldEnd()
11908 
    iprot.readStructEnd()
11909 
 
11910 
  def write(self, oprot):
11911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11913 
      return
11914 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
11915 
    if self.success is not None:
11916 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11917 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11918 
      for iter129 in self.success:
11919 
        oprot.writeI64(iter129)
5944 mandeep.dh 11920 
      oprot.writeListEnd()
11921 
      oprot.writeFieldEnd()
11922 
    if self.cex is not None:
11923 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11924 
      self.cex.write(oprot)
11925 
      oprot.writeFieldEnd()
11926 
    oprot.writeFieldStop()
11927 
    oprot.writeStructEnd()
11928 
 
11929 
  def validate(self):
11930 
    return
11931 
 
11932 
 
11933 
  def __repr__(self):
11934 
    L = ['%s=%r' % (key, value)
11935 
      for key, value in self.__dict__.iteritems()]
11936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11937 
 
11938 
  def __eq__(self, other):
11939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11940 
 
11941 
  def __ne__(self, other):
11942 
    return not (self == other)
11943 
 
11944 
class getComingSoonCount_args:
11945 
 
11946 
  thrift_spec = (
11947 
  )
11948 
 
11949 
  def read(self, iprot):
11950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11952 
      return
11953 
    iprot.readStructBegin()
11954 
    while True:
11955 
      (fname, ftype, fid) = iprot.readFieldBegin()
11956 
      if ftype == TType.STOP:
11957 
        break
11958 
      else:
11959 
        iprot.skip(ftype)
11960 
      iprot.readFieldEnd()
11961 
    iprot.readStructEnd()
11962 
 
11963 
  def write(self, oprot):
11964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11966 
      return
11967 
    oprot.writeStructBegin('getComingSoonCount_args')
11968 
    oprot.writeFieldStop()
11969 
    oprot.writeStructEnd()
11970 
 
11971 
  def validate(self):
11972 
    return
11973 
 
11974 
 
11975 
  def __repr__(self):
11976 
    L = ['%s=%r' % (key, value)
11977 
      for key, value in self.__dict__.iteritems()]
11978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11979 
 
11980 
  def __eq__(self, other):
11981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11982 
 
11983 
  def __ne__(self, other):
11984 
    return not (self == other)
11985 
 
11986 
class getComingSoonCount_result:
11987 
  """
11988 
  Attributes:
11989 
   - success
11990 
   - cex
11991 
  """
11992 
 
11993 
  thrift_spec = (
11994 
    (0, TType.I64, 'success', None, None, ), # 0
11995 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11996 
  )
11997 
 
11998 
  def __init__(self, success=None, cex=None,):
11999 
    self.success = success
12000 
    self.cex = cex
12001 
 
12002 
  def read(self, iprot):
12003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12005 
      return
12006 
    iprot.readStructBegin()
12007 
    while True:
12008 
      (fname, ftype, fid) = iprot.readFieldBegin()
12009 
      if ftype == TType.STOP:
12010 
        break
12011 
      if fid == 0:
12012 
        if ftype == TType.I64:
12013 
          self.success = iprot.readI64();
12014 
        else:
12015 
          iprot.skip(ftype)
12016 
      elif fid == 1:
12017 
        if ftype == TType.STRUCT:
12018 
          self.cex = CatalogServiceException()
12019 
          self.cex.read(iprot)
12020 
        else:
12021 
          iprot.skip(ftype)
12022 
      else:
12023 
        iprot.skip(ftype)
12024 
      iprot.readFieldEnd()
12025 
    iprot.readStructEnd()
12026 
 
12027 
  def write(self, oprot):
12028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12030 
      return
12031 
    oprot.writeStructBegin('getComingSoonCount_result')
12032 
    if self.success is not None:
12033 
      oprot.writeFieldBegin('success', TType.I64, 0)
12034 
      oprot.writeI64(self.success)
12035 
      oprot.writeFieldEnd()
12036 
    if self.cex is not None:
12037 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12038 
      self.cex.write(oprot)
12039 
      oprot.writeFieldEnd()
12040 
    oprot.writeFieldStop()
12041 
    oprot.writeStructEnd()
12042 
 
12043 
  def validate(self):
12044 
    return
12045 
 
12046 
 
12047 
  def __repr__(self):
12048 
    L = ['%s=%r' % (key, value)
12049 
      for key, value in self.__dict__.iteritems()]
12050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12051 
 
12052 
  def __eq__(self, other):
12053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12054 
 
12055 
  def __ne__(self, other):
12056 
    return not (self == other)
12057 
 
12058 
class getLatestArrivals_args:
12059 
 
12060 
  thrift_spec = (
12061 
  )
12062 
 
12063 
  def read(self, iprot):
12064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12066 
      return
12067 
    iprot.readStructBegin()
12068 
    while True:
12069 
      (fname, ftype, fid) = iprot.readFieldBegin()
12070 
      if ftype == TType.STOP:
12071 
        break
12072 
      else:
12073 
        iprot.skip(ftype)
12074 
      iprot.readFieldEnd()
12075 
    iprot.readStructEnd()
12076 
 
12077 
  def write(self, oprot):
12078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12080 
      return
12081 
    oprot.writeStructBegin('getLatestArrivals_args')
12082 
    oprot.writeFieldStop()
12083 
    oprot.writeStructEnd()
12084 
 
12085 
  def validate(self):
12086 
    return
12087 
 
12088 
 
12089 
  def __repr__(self):
12090 
    L = ['%s=%r' % (key, value)
12091 
      for key, value in self.__dict__.iteritems()]
12092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12093 
 
12094 
  def __eq__(self, other):
12095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12096 
 
12097 
  def __ne__(self, other):
12098 
    return not (self == other)
12099 
 
12100 
class getLatestArrivals_result:
12101 
  """
12102 
  Attributes:
12103 
   - success
12104 
   - isex
12105 
  """
12106 
 
12107 
  thrift_spec = (
12108 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12109 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12110 
  )
12111 
 
12112 
  def __init__(self, success=None, isex=None,):
12113 
    self.success = success
12114 
    self.isex = isex
12115 
 
12116 
  def read(self, iprot):
12117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12119 
      return
12120 
    iprot.readStructBegin()
12121 
    while True:
12122 
      (fname, ftype, fid) = iprot.readFieldBegin()
12123 
      if ftype == TType.STOP:
12124 
        break
12125 
      if fid == 0:
12126 
        if ftype == TType.LIST:
12127 
          self.success = []
8590 kshitij.so 12128 
          (_etype133, _size130) = iprot.readListBegin()
12129 
          for _i134 in xrange(_size130):
12130 
            _elem135 = Item()
12131 
            _elem135.read(iprot)
12132 
            self.success.append(_elem135)
5944 mandeep.dh 12133 
          iprot.readListEnd()
12134 
        else:
12135 
          iprot.skip(ftype)
12136 
      elif fid == 1:
12137 
        if ftype == TType.STRUCT:
12138 
          self.isex = CatalogServiceException()
12139 
          self.isex.read(iprot)
12140 
        else:
12141 
          iprot.skip(ftype)
12142 
      else:
12143 
        iprot.skip(ftype)
12144 
      iprot.readFieldEnd()
12145 
    iprot.readStructEnd()
12146 
 
12147 
  def write(self, oprot):
12148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12150 
      return
12151 
    oprot.writeStructBegin('getLatestArrivals_result')
12152 
    if self.success is not None:
12153 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12154 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12155 
      for iter136 in self.success:
12156 
        iter136.write(oprot)
5944 mandeep.dh 12157 
      oprot.writeListEnd()
12158 
      oprot.writeFieldEnd()
12159 
    if self.isex is not None:
12160 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
12161 
      self.isex.write(oprot)
12162 
      oprot.writeFieldEnd()
12163 
    oprot.writeFieldStop()
12164 
    oprot.writeStructEnd()
12165 
 
12166 
  def validate(self):
12167 
    return
12168 
 
12169 
 
12170 
  def __repr__(self):
12171 
    L = ['%s=%r' % (key, value)
12172 
      for key, value in self.__dict__.iteritems()]
12173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12174 
 
12175 
  def __eq__(self, other):
12176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12177 
 
12178 
  def __ne__(self, other):
12179 
    return not (self == other)
12180 
 
12181 
class getLatestArrivalsCatalogIds_args:
12182 
  """
12183 
  Attributes:
12184 
   - beginIndex
12185 
   - totalItems
12186 
   - brand
12187 
   - categories
12188 
  """
12189 
 
12190 
  thrift_spec = (
12191 
    None, # 0
12192 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12193 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12194 
    (3, TType.STRING, 'brand', None, None, ), # 3
12195 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
12196 
  )
12197 
 
12198 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
12199 
    self.beginIndex = beginIndex
12200 
    self.totalItems = totalItems
12201 
    self.brand = brand
12202 
    self.categories = categories
12203 
 
12204 
  def read(self, iprot):
12205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12207 
      return
12208 
    iprot.readStructBegin()
12209 
    while True:
12210 
      (fname, ftype, fid) = iprot.readFieldBegin()
12211 
      if ftype == TType.STOP:
12212 
        break
12213 
      if fid == 1:
12214 
        if ftype == TType.I64:
12215 
          self.beginIndex = iprot.readI64();
12216 
        else:
12217 
          iprot.skip(ftype)
12218 
      elif fid == 2:
12219 
        if ftype == TType.I64:
12220 
          self.totalItems = iprot.readI64();
12221 
        else:
12222 
          iprot.skip(ftype)
12223 
      elif fid == 3:
12224 
        if ftype == TType.STRING:
12225 
          self.brand = iprot.readString();
12226 
        else:
12227 
          iprot.skip(ftype)
12228 
      elif fid == 4:
12229 
        if ftype == TType.LIST:
12230 
          self.categories = []
8590 kshitij.so 12231 
          (_etype140, _size137) = iprot.readListBegin()
12232 
          for _i141 in xrange(_size137):
12233 
            _elem142 = iprot.readI64();
12234 
            self.categories.append(_elem142)
5944 mandeep.dh 12235 
          iprot.readListEnd()
12236 
        else:
12237 
          iprot.skip(ftype)
12238 
      else:
12239 
        iprot.skip(ftype)
12240 
      iprot.readFieldEnd()
12241 
    iprot.readStructEnd()
12242 
 
12243 
  def write(self, oprot):
12244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12246 
      return
12247 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
12248 
    if self.beginIndex is not None:
12249 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12250 
      oprot.writeI64(self.beginIndex)
12251 
      oprot.writeFieldEnd()
12252 
    if self.totalItems is not None:
12253 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12254 
      oprot.writeI64(self.totalItems)
12255 
      oprot.writeFieldEnd()
12256 
    if self.brand is not None:
12257 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
12258 
      oprot.writeString(self.brand)
12259 
      oprot.writeFieldEnd()
12260 
    if self.categories is not None:
12261 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
12262 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 12263 
      for iter143 in self.categories:
12264 
        oprot.writeI64(iter143)
5944 mandeep.dh 12265 
      oprot.writeListEnd()
12266 
      oprot.writeFieldEnd()
12267 
    oprot.writeFieldStop()
12268 
    oprot.writeStructEnd()
12269 
 
12270 
  def validate(self):
12271 
    return
12272 
 
12273 
 
12274 
  def __repr__(self):
12275 
    L = ['%s=%r' % (key, value)
12276 
      for key, value in self.__dict__.iteritems()]
12277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12278 
 
12279 
  def __eq__(self, other):
12280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12281 
 
12282 
  def __ne__(self, other):
12283 
    return not (self == other)
12284 
 
12285 
class getLatestArrivalsCatalogIds_result:
12286 
  """
12287 
  Attributes:
12288 
   - success
12289 
   - cex
12290 
  """
12291 
 
12292 
  thrift_spec = (
12293 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12294 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12295 
  )
12296 
 
12297 
  def __init__(self, success=None, cex=None,):
12298 
    self.success = success
12299 
    self.cex = cex
12300 
 
12301 
  def read(self, iprot):
12302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12304 
      return
12305 
    iprot.readStructBegin()
12306 
    while True:
12307 
      (fname, ftype, fid) = iprot.readFieldBegin()
12308 
      if ftype == TType.STOP:
12309 
        break
12310 
      if fid == 0:
12311 
        if ftype == TType.LIST:
12312 
          self.success = []
8590 kshitij.so 12313 
          (_etype147, _size144) = iprot.readListBegin()
12314 
          for _i148 in xrange(_size144):
12315 
            _elem149 = iprot.readI64();
12316 
            self.success.append(_elem149)
5944 mandeep.dh 12317 
          iprot.readListEnd()
12318 
        else:
12319 
          iprot.skip(ftype)
12320 
      elif fid == 1:
12321 
        if ftype == TType.STRUCT:
12322 
          self.cex = CatalogServiceException()
12323 
          self.cex.read(iprot)
12324 
        else:
12325 
          iprot.skip(ftype)
12326 
      else:
12327 
        iprot.skip(ftype)
12328 
      iprot.readFieldEnd()
12329 
    iprot.readStructEnd()
12330 
 
12331 
  def write(self, oprot):
12332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12334 
      return
12335 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
12336 
    if self.success is not None:
12337 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12338 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12339 
      for iter150 in self.success:
12340 
        oprot.writeI64(iter150)
5944 mandeep.dh 12341 
      oprot.writeListEnd()
12342 
      oprot.writeFieldEnd()
12343 
    if self.cex is not None:
12344 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12345 
      self.cex.write(oprot)
12346 
      oprot.writeFieldEnd()
12347 
    oprot.writeFieldStop()
12348 
    oprot.writeStructEnd()
12349 
 
12350 
  def validate(self):
12351 
    return
12352 
 
12353 
 
12354 
  def __repr__(self):
12355 
    L = ['%s=%r' % (key, value)
12356 
      for key, value in self.__dict__.iteritems()]
12357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12358 
 
12359 
  def __eq__(self, other):
12360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12361 
 
12362 
  def __ne__(self, other):
12363 
    return not (self == other)
12364 
 
12365 
class getLatestArrivalsCount_args:
12366 
 
12367 
  thrift_spec = (
12368 
  )
12369 
 
12370 
  def read(self, iprot):
12371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12373 
      return
12374 
    iprot.readStructBegin()
12375 
    while True:
12376 
      (fname, ftype, fid) = iprot.readFieldBegin()
12377 
      if ftype == TType.STOP:
12378 
        break
12379 
      else:
12380 
        iprot.skip(ftype)
12381 
      iprot.readFieldEnd()
12382 
    iprot.readStructEnd()
12383 
 
12384 
  def write(self, oprot):
12385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12387 
      return
12388 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
12389 
    oprot.writeFieldStop()
12390 
    oprot.writeStructEnd()
12391 
 
12392 
  def validate(self):
12393 
    return
12394 
 
12395 
 
12396 
  def __repr__(self):
12397 
    L = ['%s=%r' % (key, value)
12398 
      for key, value in self.__dict__.iteritems()]
12399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12400 
 
12401 
  def __eq__(self, other):
12402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12403 
 
12404 
  def __ne__(self, other):
12405 
    return not (self == other)
12406 
 
12407 
class getLatestArrivalsCount_result:
12408 
  """
12409 
  Attributes:
12410 
   - success
12411 
   - cex
12412 
  """
12413 
 
12414 
  thrift_spec = (
12415 
    (0, TType.I64, 'success', None, None, ), # 0
12416 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12417 
  )
12418 
 
12419 
  def __init__(self, success=None, cex=None,):
12420 
    self.success = success
12421 
    self.cex = cex
12422 
 
12423 
  def read(self, iprot):
12424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12426 
      return
12427 
    iprot.readStructBegin()
12428 
    while True:
12429 
      (fname, ftype, fid) = iprot.readFieldBegin()
12430 
      if ftype == TType.STOP:
12431 
        break
12432 
      if fid == 0:
12433 
        if ftype == TType.I64:
12434 
          self.success = iprot.readI64();
12435 
        else:
12436 
          iprot.skip(ftype)
12437 
      elif fid == 1:
12438 
        if ftype == TType.STRUCT:
12439 
          self.cex = CatalogServiceException()
12440 
          self.cex.read(iprot)
12441 
        else:
12442 
          iprot.skip(ftype)
12443 
      else:
12444 
        iprot.skip(ftype)
12445 
      iprot.readFieldEnd()
12446 
    iprot.readStructEnd()
12447 
 
12448 
  def write(self, oprot):
12449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12451 
      return
12452 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
12453 
    if self.success is not None:
12454 
      oprot.writeFieldBegin('success', TType.I64, 0)
12455 
      oprot.writeI64(self.success)
12456 
      oprot.writeFieldEnd()
12457 
    if self.cex is not None:
12458 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12459 
      self.cex.write(oprot)
12460 
      oprot.writeFieldEnd()
12461 
    oprot.writeFieldStop()
12462 
    oprot.writeStructEnd()
12463 
 
12464 
  def validate(self):
12465 
    return
12466 
 
12467 
 
12468 
  def __repr__(self):
12469 
    L = ['%s=%r' % (key, value)
12470 
      for key, value in self.__dict__.iteritems()]
12471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12472 
 
12473 
  def __eq__(self, other):
12474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12475 
 
12476 
  def __ne__(self, other):
12477 
    return not (self == other)
12478 
 
12479 
class generateNewEntityID_args:
12480 
 
12481 
  thrift_spec = (
12482 
  )
12483 
 
12484 
  def read(self, iprot):
12485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12487 
      return
12488 
    iprot.readStructBegin()
12489 
    while True:
12490 
      (fname, ftype, fid) = iprot.readFieldBegin()
12491 
      if ftype == TType.STOP:
12492 
        break
12493 
      else:
12494 
        iprot.skip(ftype)
12495 
      iprot.readFieldEnd()
12496 
    iprot.readStructEnd()
12497 
 
12498 
  def write(self, oprot):
12499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12501 
      return
12502 
    oprot.writeStructBegin('generateNewEntityID_args')
12503 
    oprot.writeFieldStop()
12504 
    oprot.writeStructEnd()
12505 
 
12506 
  def validate(self):
12507 
    return
12508 
 
12509 
 
12510 
  def __repr__(self):
12511 
    L = ['%s=%r' % (key, value)
12512 
      for key, value in self.__dict__.iteritems()]
12513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12514 
 
12515 
  def __eq__(self, other):
12516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12517 
 
12518 
  def __ne__(self, other):
12519 
    return not (self == other)
12520 
 
12521 
class generateNewEntityID_result:
12522 
  """
12523 
  Attributes:
12524 
   - success
12525 
  """
12526 
 
12527 
  thrift_spec = (
12528 
    (0, TType.I64, 'success', None, None, ), # 0
12529 
  )
12530 
 
12531 
  def __init__(self, success=None,):
12532 
    self.success = success
12533 
 
12534 
  def read(self, iprot):
12535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12537 
      return
12538 
    iprot.readStructBegin()
12539 
    while True:
12540 
      (fname, ftype, fid) = iprot.readFieldBegin()
12541 
      if ftype == TType.STOP:
12542 
        break
12543 
      if fid == 0:
12544 
        if ftype == TType.I64:
12545 
          self.success = iprot.readI64();
12546 
        else:
12547 
          iprot.skip(ftype)
12548 
      else:
12549 
        iprot.skip(ftype)
12550 
      iprot.readFieldEnd()
12551 
    iprot.readStructEnd()
12552 
 
12553 
  def write(self, oprot):
12554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12556 
      return
12557 
    oprot.writeStructBegin('generateNewEntityID_result')
12558 
    if self.success is not None:
12559 
      oprot.writeFieldBegin('success', TType.I64, 0)
12560 
      oprot.writeI64(self.success)
12561 
      oprot.writeFieldEnd()
12562 
    oprot.writeFieldStop()
12563 
    oprot.writeStructEnd()
12564 
 
12565 
  def validate(self):
12566 
    return
12567 
 
12568 
 
12569 
  def __repr__(self):
12570 
    L = ['%s=%r' % (key, value)
12571 
      for key, value in self.__dict__.iteritems()]
12572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12573 
 
12574 
  def __eq__(self, other):
12575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12576 
 
12577 
  def __ne__(self, other):
12578 
    return not (self == other)
12579 
 
12580 
class addCategory_args:
12581 
  """
12582 
  Attributes:
12583 
   - category
12584 
  """
12585 
 
12586 
  thrift_spec = (
12587 
    None, # 0
12588 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
12589 
  )
12590 
 
12591 
  def __init__(self, category=None,):
12592 
    self.category = category
12593 
 
12594 
  def read(self, iprot):
12595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12597 
      return
12598 
    iprot.readStructBegin()
12599 
    while True:
12600 
      (fname, ftype, fid) = iprot.readFieldBegin()
12601 
      if ftype == TType.STOP:
12602 
        break
12603 
      if fid == 1:
12604 
        if ftype == TType.STRUCT:
12605 
          self.category = Category()
12606 
          self.category.read(iprot)
12607 
        else:
12608 
          iprot.skip(ftype)
12609 
      else:
12610 
        iprot.skip(ftype)
12611 
      iprot.readFieldEnd()
12612 
    iprot.readStructEnd()
12613 
 
12614 
  def write(self, oprot):
12615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12617 
      return
12618 
    oprot.writeStructBegin('addCategory_args')
12619 
    if self.category is not None:
12620 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
12621 
      self.category.write(oprot)
12622 
      oprot.writeFieldEnd()
12623 
    oprot.writeFieldStop()
12624 
    oprot.writeStructEnd()
12625 
 
12626 
  def validate(self):
12627 
    return
12628 
 
12629 
 
12630 
  def __repr__(self):
12631 
    L = ['%s=%r' % (key, value)
12632 
      for key, value in self.__dict__.iteritems()]
12633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12634 
 
12635 
  def __eq__(self, other):
12636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12637 
 
12638 
  def __ne__(self, other):
12639 
    return not (self == other)
12640 
 
12641 
class addCategory_result:
12642 
  """
12643 
  Attributes:
12644 
   - success
12645 
  """
12646 
 
12647 
  thrift_spec = (
12648 
    (0, TType.BOOL, 'success', None, None, ), # 0
12649 
  )
12650 
 
12651 
  def __init__(self, success=None,):
12652 
    self.success = success
12653 
 
12654 
  def read(self, iprot):
12655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12657 
      return
12658 
    iprot.readStructBegin()
12659 
    while True:
12660 
      (fname, ftype, fid) = iprot.readFieldBegin()
12661 
      if ftype == TType.STOP:
12662 
        break
12663 
      if fid == 0:
12664 
        if ftype == TType.BOOL:
12665 
          self.success = iprot.readBool();
12666 
        else:
12667 
          iprot.skip(ftype)
12668 
      else:
12669 
        iprot.skip(ftype)
12670 
      iprot.readFieldEnd()
12671 
    iprot.readStructEnd()
12672 
 
12673 
  def write(self, oprot):
12674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12676 
      return
12677 
    oprot.writeStructBegin('addCategory_result')
12678 
    if self.success is not None:
12679 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12680 
      oprot.writeBool(self.success)
12681 
      oprot.writeFieldEnd()
12682 
    oprot.writeFieldStop()
12683 
    oprot.writeStructEnd()
12684 
 
12685 
  def validate(self):
12686 
    return
12687 
 
12688 
 
12689 
  def __repr__(self):
12690 
    L = ['%s=%r' % (key, value)
12691 
      for key, value in self.__dict__.iteritems()]
12692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12693 
 
12694 
  def __eq__(self, other):
12695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12696 
 
12697 
  def __ne__(self, other):
12698 
    return not (self == other)
12699 
 
12700 
class getCategory_args:
12701 
  """
12702 
  Attributes:
12703 
   - id
12704 
  """
12705 
 
12706 
  thrift_spec = (
12707 
    None, # 0
12708 
    (1, TType.I64, 'id', None, None, ), # 1
12709 
  )
12710 
 
12711 
  def __init__(self, id=None,):
12712 
    self.id = id
12713 
 
12714 
  def read(self, iprot):
12715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12717 
      return
12718 
    iprot.readStructBegin()
12719 
    while True:
12720 
      (fname, ftype, fid) = iprot.readFieldBegin()
12721 
      if ftype == TType.STOP:
12722 
        break
12723 
      if fid == 1:
12724 
        if ftype == TType.I64:
12725 
          self.id = iprot.readI64();
12726 
        else:
12727 
          iprot.skip(ftype)
12728 
      else:
12729 
        iprot.skip(ftype)
12730 
      iprot.readFieldEnd()
12731 
    iprot.readStructEnd()
12732 
 
12733 
  def write(self, oprot):
12734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12736 
      return
12737 
    oprot.writeStructBegin('getCategory_args')
12738 
    if self.id is not None:
12739 
      oprot.writeFieldBegin('id', TType.I64, 1)
12740 
      oprot.writeI64(self.id)
12741 
      oprot.writeFieldEnd()
12742 
    oprot.writeFieldStop()
12743 
    oprot.writeStructEnd()
12744 
 
12745 
  def validate(self):
12746 
    return
12747 
 
12748 
 
12749 
  def __repr__(self):
12750 
    L = ['%s=%r' % (key, value)
12751 
      for key, value in self.__dict__.iteritems()]
12752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12753 
 
12754 
  def __eq__(self, other):
12755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12756 
 
12757 
  def __ne__(self, other):
12758 
    return not (self == other)
12759 
 
12760 
class getCategory_result:
12761 
  """
12762 
  Attributes:
12763 
   - success
12764 
  """
12765 
 
12766 
  thrift_spec = (
12767 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
12768 
  )
12769 
 
12770 
  def __init__(self, success=None,):
12771 
    self.success = success
12772 
 
12773 
  def read(self, iprot):
12774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12776 
      return
12777 
    iprot.readStructBegin()
12778 
    while True:
12779 
      (fname, ftype, fid) = iprot.readFieldBegin()
12780 
      if ftype == TType.STOP:
12781 
        break
12782 
      if fid == 0:
12783 
        if ftype == TType.STRUCT:
12784 
          self.success = Category()
12785 
          self.success.read(iprot)
12786 
        else:
12787 
          iprot.skip(ftype)
12788 
      else:
12789 
        iprot.skip(ftype)
12790 
      iprot.readFieldEnd()
12791 
    iprot.readStructEnd()
12792 
 
12793 
  def write(self, oprot):
12794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12796 
      return
12797 
    oprot.writeStructBegin('getCategory_result')
12798 
    if self.success is not None:
12799 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12800 
      self.success.write(oprot)
12801 
      oprot.writeFieldEnd()
12802 
    oprot.writeFieldStop()
12803 
    oprot.writeStructEnd()
12804 
 
12805 
  def validate(self):
12806 
    return
12807 
 
12808 
 
12809 
  def __repr__(self):
12810 
    L = ['%s=%r' % (key, value)
12811 
      for key, value in self.__dict__.iteritems()]
12812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12813 
 
12814 
  def __eq__(self, other):
12815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12816 
 
12817 
  def __ne__(self, other):
12818 
    return not (self == other)
12819 
 
12820 
class getAllCategories_args:
12821 
 
12822 
  thrift_spec = (
12823 
  )
12824 
 
12825 
  def read(self, iprot):
12826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12828 
      return
12829 
    iprot.readStructBegin()
12830 
    while True:
12831 
      (fname, ftype, fid) = iprot.readFieldBegin()
12832 
      if ftype == TType.STOP:
12833 
        break
12834 
      else:
12835 
        iprot.skip(ftype)
12836 
      iprot.readFieldEnd()
12837 
    iprot.readStructEnd()
12838 
 
12839 
  def write(self, oprot):
12840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12842 
      return
12843 
    oprot.writeStructBegin('getAllCategories_args')
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 
 
12862 
class getAllCategories_result:
12863 
  """
12864 
  Attributes:
12865 
   - success
12866 
  """
12867 
 
12868 
  thrift_spec = (
12869 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
12870 
  )
12871 
 
12872 
  def __init__(self, success=None,):
12873 
    self.success = success
12874 
 
12875 
  def read(self, iprot):
12876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12878 
      return
12879 
    iprot.readStructBegin()
12880 
    while True:
12881 
      (fname, ftype, fid) = iprot.readFieldBegin()
12882 
      if ftype == TType.STOP:
12883 
        break
12884 
      if fid == 0:
12885 
        if ftype == TType.LIST:
12886 
          self.success = []
8590 kshitij.so 12887 
          (_etype154, _size151) = iprot.readListBegin()
12888 
          for _i155 in xrange(_size151):
12889 
            _elem156 = Category()
12890 
            _elem156.read(iprot)
12891 
            self.success.append(_elem156)
5944 mandeep.dh 12892 
          iprot.readListEnd()
12893 
        else:
12894 
          iprot.skip(ftype)
12895 
      else:
12896 
        iprot.skip(ftype)
12897 
      iprot.readFieldEnd()
12898 
    iprot.readStructEnd()
12899 
 
12900 
  def write(self, oprot):
12901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12903 
      return
12904 
    oprot.writeStructBegin('getAllCategories_result')
12905 
    if self.success is not None:
12906 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12907 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12908 
      for iter157 in self.success:
12909 
        iter157.write(oprot)
5944 mandeep.dh 12910 
      oprot.writeListEnd()
12911 
      oprot.writeFieldEnd()
12912 
    oprot.writeFieldStop()
12913 
    oprot.writeStructEnd()
12914 
 
12915 
  def validate(self):
12916 
    return
12917 
 
12918 
 
12919 
  def __repr__(self):
12920 
    L = ['%s=%r' % (key, value)
12921 
      for key, value in self.__dict__.iteritems()]
12922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12923 
 
12924 
  def __eq__(self, other):
12925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12926 
 
12927 
  def __ne__(self, other):
12928 
    return not (self == other)
12929 
 
12930 
class getAllSimilarItems_args:
12931 
  """
12932 
  Attributes:
12933 
   - itemId
12934 
  """
12935 
 
12936 
  thrift_spec = (
12937 
    None, # 0
12938 
    (1, TType.I64, 'itemId', None, None, ), # 1
12939 
  )
12940 
 
12941 
  def __init__(self, itemId=None,):
12942 
    self.itemId = itemId
12943 
 
12944 
  def read(self, iprot):
12945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12947 
      return
12948 
    iprot.readStructBegin()
12949 
    while True:
12950 
      (fname, ftype, fid) = iprot.readFieldBegin()
12951 
      if ftype == TType.STOP:
12952 
        break
12953 
      if fid == 1:
12954 
        if ftype == TType.I64:
12955 
          self.itemId = iprot.readI64();
12956 
        else:
12957 
          iprot.skip(ftype)
12958 
      else:
12959 
        iprot.skip(ftype)
12960 
      iprot.readFieldEnd()
12961 
    iprot.readStructEnd()
12962 
 
12963 
  def write(self, oprot):
12964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12966 
      return
12967 
    oprot.writeStructBegin('getAllSimilarItems_args')
12968 
    if self.itemId is not None:
12969 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12970 
      oprot.writeI64(self.itemId)
12971 
      oprot.writeFieldEnd()
12972 
    oprot.writeFieldStop()
12973 
    oprot.writeStructEnd()
12974 
 
12975 
  def validate(self):
12976 
    return
12977 
 
12978 
 
12979 
  def __repr__(self):
12980 
    L = ['%s=%r' % (key, value)
12981 
      for key, value in self.__dict__.iteritems()]
12982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12983 
 
12984 
  def __eq__(self, other):
12985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12986 
 
12987 
  def __ne__(self, other):
12988 
    return not (self == other)
12989 
 
12990 
class getAllSimilarItems_result:
12991 
  """
12992 
  Attributes:
12993 
   - success
12994 
  """
12995 
 
12996 
  thrift_spec = (
12997 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12998 
  )
12999 
 
13000 
  def __init__(self, success=None,):
13001 
    self.success = success
13002 
 
13003 
  def read(self, iprot):
13004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13006 
      return
13007 
    iprot.readStructBegin()
13008 
    while True:
13009 
      (fname, ftype, fid) = iprot.readFieldBegin()
13010 
      if ftype == TType.STOP:
13011 
        break
13012 
      if fid == 0:
13013 
        if ftype == TType.LIST:
13014 
          self.success = []
8590 kshitij.so 13015 
          (_etype161, _size158) = iprot.readListBegin()
13016 
          for _i162 in xrange(_size158):
13017 
            _elem163 = Item()
13018 
            _elem163.read(iprot)
13019 
            self.success.append(_elem163)
5944 mandeep.dh 13020 
          iprot.readListEnd()
13021 
        else:
13022 
          iprot.skip(ftype)
13023 
      else:
13024 
        iprot.skip(ftype)
13025 
      iprot.readFieldEnd()
13026 
    iprot.readStructEnd()
13027 
 
13028 
  def write(self, oprot):
13029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13031 
      return
13032 
    oprot.writeStructBegin('getAllSimilarItems_result')
13033 
    if self.success is not None:
13034 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13035 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13036 
      for iter164 in self.success:
13037 
        iter164.write(oprot)
5944 mandeep.dh 13038 
      oprot.writeListEnd()
13039 
      oprot.writeFieldEnd()
13040 
    oprot.writeFieldStop()
13041 
    oprot.writeStructEnd()
13042 
 
13043 
  def validate(self):
13044 
    return
13045 
 
13046 
 
13047 
  def __repr__(self):
13048 
    L = ['%s=%r' % (key, value)
13049 
      for key, value in self.__dict__.iteritems()]
13050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13051 
 
13052 
  def __eq__(self, other):
13053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13054 
 
13055 
  def __ne__(self, other):
13056 
    return not (self == other)
13057 
 
13058 
class addSimilarItem_args:
13059 
  """
13060 
  Attributes:
13061 
   - itemId
13062 
   - catalogItemId
13063 
  """
13064 
 
13065 
  thrift_spec = (
13066 
    None, # 0
13067 
    (1, TType.I64, 'itemId', None, None, ), # 1
13068 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
13069 
  )
13070 
 
13071 
  def __init__(self, itemId=None, catalogItemId=None,):
13072 
    self.itemId = itemId
13073 
    self.catalogItemId = catalogItemId
13074 
 
13075 
  def read(self, iprot):
13076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13078 
      return
13079 
    iprot.readStructBegin()
13080 
    while True:
13081 
      (fname, ftype, fid) = iprot.readFieldBegin()
13082 
      if ftype == TType.STOP:
13083 
        break
13084 
      if fid == 1:
13085 
        if ftype == TType.I64:
13086 
          self.itemId = iprot.readI64();
13087 
        else:
13088 
          iprot.skip(ftype)
13089 
      elif fid == 2:
13090 
        if ftype == TType.I64:
13091 
          self.catalogItemId = iprot.readI64();
13092 
        else:
13093 
          iprot.skip(ftype)
13094 
      else:
13095 
        iprot.skip(ftype)
13096 
      iprot.readFieldEnd()
13097 
    iprot.readStructEnd()
13098 
 
13099 
  def write(self, oprot):
13100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13102 
      return
13103 
    oprot.writeStructBegin('addSimilarItem_args')
13104 
    if self.itemId is not None:
13105 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13106 
      oprot.writeI64(self.itemId)
13107 
      oprot.writeFieldEnd()
13108 
    if self.catalogItemId is not None:
13109 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
13110 
      oprot.writeI64(self.catalogItemId)
13111 
      oprot.writeFieldEnd()
13112 
    oprot.writeFieldStop()
13113 
    oprot.writeStructEnd()
13114 
 
13115 
  def validate(self):
13116 
    return
13117 
 
13118 
 
13119 
  def __repr__(self):
13120 
    L = ['%s=%r' % (key, value)
13121 
      for key, value in self.__dict__.iteritems()]
13122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13123 
 
13124 
  def __eq__(self, other):
13125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13126 
 
13127 
  def __ne__(self, other):
13128 
    return not (self == other)
13129 
 
13130 
class addSimilarItem_result:
13131 
  """
13132 
  Attributes:
13133 
   - success
13134 
   - cex
13135 
  """
13136 
 
13137 
  thrift_spec = (
13138 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13139 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13140 
  )
13141 
 
13142 
  def __init__(self, success=None, cex=None,):
13143 
    self.success = success
13144 
    self.cex = cex
13145 
 
13146 
  def read(self, iprot):
13147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13149 
      return
13150 
    iprot.readStructBegin()
13151 
    while True:
13152 
      (fname, ftype, fid) = iprot.readFieldBegin()
13153 
      if ftype == TType.STOP:
13154 
        break
13155 
      if fid == 0:
13156 
        if ftype == TType.STRUCT:
13157 
          self.success = Item()
13158 
          self.success.read(iprot)
13159 
        else:
13160 
          iprot.skip(ftype)
13161 
      elif fid == 1:
13162 
        if ftype == TType.STRUCT:
13163 
          self.cex = CatalogServiceException()
13164 
          self.cex.read(iprot)
13165 
        else:
13166 
          iprot.skip(ftype)
13167 
      else:
13168 
        iprot.skip(ftype)
13169 
      iprot.readFieldEnd()
13170 
    iprot.readStructEnd()
13171 
 
13172 
  def write(self, oprot):
13173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13175 
      return
13176 
    oprot.writeStructBegin('addSimilarItem_result')
13177 
    if self.success is not None:
13178 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13179 
      self.success.write(oprot)
13180 
      oprot.writeFieldEnd()
13181 
    if self.cex is not None:
13182 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13183 
      self.cex.write(oprot)
13184 
      oprot.writeFieldEnd()
13185 
    oprot.writeFieldStop()
13186 
    oprot.writeStructEnd()
13187 
 
13188 
  def validate(self):
13189 
    return
13190 
 
13191 
 
13192 
  def __repr__(self):
13193 
    L = ['%s=%r' % (key, value)
13194 
      for key, value in self.__dict__.iteritems()]
13195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13196 
 
13197 
  def __eq__(self, other):
13198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13199 
 
13200 
  def __ne__(self, other):
13201 
    return not (self == other)
13202 
 
6512 kshitij.so 13203 
class addTag_args:
13204 
  """
13205 
  Attributes:
13206 
   - displayName
13207 
   - itemId
13208 
  """
13209 
 
13210 
  thrift_spec = (
13211 
    None, # 0
13212 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13213 
    (2, TType.I64, 'itemId', None, None, ), # 2
13214 
  )
13215 
 
13216 
  def __init__(self, displayName=None, itemId=None,):
13217 
    self.displayName = displayName
13218 
    self.itemId = itemId
13219 
 
13220 
  def read(self, iprot):
13221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13223 
      return
13224 
    iprot.readStructBegin()
13225 
    while True:
13226 
      (fname, ftype, fid) = iprot.readFieldBegin()
13227 
      if ftype == TType.STOP:
13228 
        break
13229 
      if fid == 1:
13230 
        if ftype == TType.STRING:
13231 
          self.displayName = iprot.readString();
13232 
        else:
13233 
          iprot.skip(ftype)
13234 
      elif fid == 2:
13235 
        if ftype == TType.I64:
13236 
          self.itemId = iprot.readI64();
13237 
        else:
13238 
          iprot.skip(ftype)
13239 
      else:
13240 
        iprot.skip(ftype)
13241 
      iprot.readFieldEnd()
13242 
    iprot.readStructEnd()
13243 
 
13244 
  def write(self, oprot):
13245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13247 
      return
13248 
    oprot.writeStructBegin('addTag_args')
13249 
    if self.displayName is not None:
13250 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13251 
      oprot.writeString(self.displayName)
13252 
      oprot.writeFieldEnd()
13253 
    if self.itemId is not None:
13254 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13255 
      oprot.writeI64(self.itemId)
13256 
      oprot.writeFieldEnd()
13257 
    oprot.writeFieldStop()
13258 
    oprot.writeStructEnd()
13259 
 
13260 
  def validate(self):
13261 
    return
13262 
 
13263 
 
13264 
  def __repr__(self):
13265 
    L = ['%s=%r' % (key, value)
13266 
      for key, value in self.__dict__.iteritems()]
13267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13268 
 
13269 
  def __eq__(self, other):
13270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13271 
 
13272 
  def __ne__(self, other):
13273 
    return not (self == other)
13274 
 
13275 
class addTag_result:
13276 
  """
13277 
  Attributes:
13278 
   - success
13279 
  """
13280 
 
13281 
  thrift_spec = (
13282 
    (0, TType.BOOL, 'success', None, None, ), # 0
13283 
  )
13284 
 
13285 
  def __init__(self, success=None,):
13286 
    self.success = success
13287 
 
13288 
  def read(self, iprot):
13289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13291 
      return
13292 
    iprot.readStructBegin()
13293 
    while True:
13294 
      (fname, ftype, fid) = iprot.readFieldBegin()
13295 
      if ftype == TType.STOP:
13296 
        break
13297 
      if fid == 0:
13298 
        if ftype == TType.BOOL:
13299 
          self.success = iprot.readBool();
13300 
        else:
13301 
          iprot.skip(ftype)
13302 
      else:
13303 
        iprot.skip(ftype)
13304 
      iprot.readFieldEnd()
13305 
    iprot.readStructEnd()
13306 
 
13307 
  def write(self, oprot):
13308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13310 
      return
13311 
    oprot.writeStructBegin('addTag_result')
13312 
    if self.success is not None:
13313 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13314 
      oprot.writeBool(self.success)
13315 
      oprot.writeFieldEnd()
13316 
    oprot.writeFieldStop()
13317 
    oprot.writeStructEnd()
13318 
 
13319 
  def validate(self):
13320 
    return
13321 
 
13322 
 
13323 
  def __repr__(self):
13324 
    L = ['%s=%r' % (key, value)
13325 
      for key, value in self.__dict__.iteritems()]
13326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13327 
 
13328 
  def __eq__(self, other):
13329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13330 
 
13331 
  def __ne__(self, other):
13332 
    return not (self == other)
13333 
 
13334 
class deleteEntityTag_args:
13335 
  """
13336 
  Attributes:
13337 
   - displayName
13338 
   - itemId
13339 
  """
13340 
 
13341 
  thrift_spec = (
13342 
    None, # 0
13343 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13344 
    (2, TType.I64, 'itemId', None, None, ), # 2
13345 
  )
13346 
 
13347 
  def __init__(self, displayName=None, itemId=None,):
13348 
    self.displayName = displayName
13349 
    self.itemId = itemId
13350 
 
13351 
  def read(self, iprot):
13352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13354 
      return
13355 
    iprot.readStructBegin()
13356 
    while True:
13357 
      (fname, ftype, fid) = iprot.readFieldBegin()
13358 
      if ftype == TType.STOP:
13359 
        break
13360 
      if fid == 1:
13361 
        if ftype == TType.STRING:
13362 
          self.displayName = iprot.readString();
13363 
        else:
13364 
          iprot.skip(ftype)
13365 
      elif fid == 2:
13366 
        if ftype == TType.I64:
13367 
          self.itemId = iprot.readI64();
13368 
        else:
13369 
          iprot.skip(ftype)
13370 
      else:
13371 
        iprot.skip(ftype)
13372 
      iprot.readFieldEnd()
13373 
    iprot.readStructEnd()
13374 
 
13375 
  def write(self, oprot):
13376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13378 
      return
13379 
    oprot.writeStructBegin('deleteEntityTag_args')
13380 
    if self.displayName is not None:
13381 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13382 
      oprot.writeString(self.displayName)
13383 
      oprot.writeFieldEnd()
13384 
    if self.itemId is not None:
13385 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13386 
      oprot.writeI64(self.itemId)
13387 
      oprot.writeFieldEnd()
13388 
    oprot.writeFieldStop()
13389 
    oprot.writeStructEnd()
13390 
 
13391 
  def validate(self):
13392 
    return
13393 
 
13394 
 
13395 
  def __repr__(self):
13396 
    L = ['%s=%r' % (key, value)
13397 
      for key, value in self.__dict__.iteritems()]
13398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13399 
 
13400 
  def __eq__(self, other):
13401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13402 
 
13403 
  def __ne__(self, other):
13404 
    return not (self == other)
13405 
 
13406 
class deleteEntityTag_result:
13407 
  """
13408 
  Attributes:
13409 
   - success
13410 
  """
13411 
 
13412 
  thrift_spec = (
13413 
    (0, TType.BOOL, 'success', None, None, ), # 0
13414 
  )
13415 
 
13416 
  def __init__(self, success=None,):
13417 
    self.success = success
13418 
 
13419 
  def read(self, iprot):
13420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13422 
      return
13423 
    iprot.readStructBegin()
13424 
    while True:
13425 
      (fname, ftype, fid) = iprot.readFieldBegin()
13426 
      if ftype == TType.STOP:
13427 
        break
13428 
      if fid == 0:
13429 
        if ftype == TType.BOOL:
13430 
          self.success = iprot.readBool();
13431 
        else:
13432 
          iprot.skip(ftype)
13433 
      else:
13434 
        iprot.skip(ftype)
13435 
      iprot.readFieldEnd()
13436 
    iprot.readStructEnd()
13437 
 
13438 
  def write(self, oprot):
13439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13441 
      return
13442 
    oprot.writeStructBegin('deleteEntityTag_result')
13443 
    if self.success is not None:
13444 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13445 
      oprot.writeBool(self.success)
13446 
      oprot.writeFieldEnd()
13447 
    oprot.writeFieldStop()
13448 
    oprot.writeStructEnd()
13449 
 
13450 
  def validate(self):
13451 
    return
13452 
 
13453 
 
13454 
  def __repr__(self):
13455 
    L = ['%s=%r' % (key, value)
13456 
      for key, value in self.__dict__.iteritems()]
13457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13458 
 
13459 
  def __eq__(self, other):
13460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13461 
 
13462 
  def __ne__(self, other):
13463 
    return not (self == other)
13464 
 
13465 
class deleteTag_args:
13466 
  """
13467 
  Attributes:
13468 
   - displayName
13469 
  """
13470 
 
13471 
  thrift_spec = (
13472 
    None, # 0
13473 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13474 
  )
13475 
 
13476 
  def __init__(self, displayName=None,):
13477 
    self.displayName = displayName
13478 
 
13479 
  def read(self, iprot):
13480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13482 
      return
13483 
    iprot.readStructBegin()
13484 
    while True:
13485 
      (fname, ftype, fid) = iprot.readFieldBegin()
13486 
      if ftype == TType.STOP:
13487 
        break
13488 
      if fid == 1:
13489 
        if ftype == TType.STRING:
13490 
          self.displayName = iprot.readString();
13491 
        else:
13492 
          iprot.skip(ftype)
13493 
      else:
13494 
        iprot.skip(ftype)
13495 
      iprot.readFieldEnd()
13496 
    iprot.readStructEnd()
13497 
 
13498 
  def write(self, oprot):
13499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13501 
      return
13502 
    oprot.writeStructBegin('deleteTag_args')
13503 
    if self.displayName is not None:
13504 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13505 
      oprot.writeString(self.displayName)
13506 
      oprot.writeFieldEnd()
13507 
    oprot.writeFieldStop()
13508 
    oprot.writeStructEnd()
13509 
 
13510 
  def validate(self):
13511 
    return
13512 
 
13513 
 
13514 
  def __repr__(self):
13515 
    L = ['%s=%r' % (key, value)
13516 
      for key, value in self.__dict__.iteritems()]
13517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13518 
 
13519 
  def __eq__(self, other):
13520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13521 
 
13522 
  def __ne__(self, other):
13523 
    return not (self == other)
13524 
 
13525 
class deleteTag_result:
13526 
  """
13527 
  Attributes:
13528 
   - success
13529 
  """
13530 
 
13531 
  thrift_spec = (
13532 
    (0, TType.BOOL, 'success', None, None, ), # 0
13533 
  )
13534 
 
13535 
  def __init__(self, success=None,):
13536 
    self.success = success
13537 
 
13538 
  def read(self, iprot):
13539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13541 
      return
13542 
    iprot.readStructBegin()
13543 
    while True:
13544 
      (fname, ftype, fid) = iprot.readFieldBegin()
13545 
      if ftype == TType.STOP:
13546 
        break
13547 
      if fid == 0:
13548 
        if ftype == TType.BOOL:
13549 
          self.success = iprot.readBool();
13550 
        else:
13551 
          iprot.skip(ftype)
13552 
      else:
13553 
        iprot.skip(ftype)
13554 
      iprot.readFieldEnd()
13555 
    iprot.readStructEnd()
13556 
 
13557 
  def write(self, oprot):
13558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13560 
      return
13561 
    oprot.writeStructBegin('deleteTag_result')
13562 
    if self.success is not None:
13563 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13564 
      oprot.writeBool(self.success)
13565 
      oprot.writeFieldEnd()
13566 
    oprot.writeFieldStop()
13567 
    oprot.writeStructEnd()
13568 
 
13569 
  def validate(self):
13570 
    return
13571 
 
13572 
 
13573 
  def __repr__(self):
13574 
    L = ['%s=%r' % (key, value)
13575 
      for key, value in self.__dict__.iteritems()]
13576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13577 
 
13578 
  def __eq__(self, other):
13579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13580 
 
13581 
  def __ne__(self, other):
13582 
    return not (self == other)
13583 
 
13584 
class getAllTags_args:
13585 
 
13586 
  thrift_spec = (
13587 
  )
13588 
 
13589 
  def read(self, iprot):
13590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13592 
      return
13593 
    iprot.readStructBegin()
13594 
    while True:
13595 
      (fname, ftype, fid) = iprot.readFieldBegin()
13596 
      if ftype == TType.STOP:
13597 
        break
13598 
      else:
13599 
        iprot.skip(ftype)
13600 
      iprot.readFieldEnd()
13601 
    iprot.readStructEnd()
13602 
 
13603 
  def write(self, oprot):
13604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13606 
      return
13607 
    oprot.writeStructBegin('getAllTags_args')
13608 
    oprot.writeFieldStop()
13609 
    oprot.writeStructEnd()
13610 
 
13611 
  def validate(self):
13612 
    return
13613 
 
13614 
 
13615 
  def __repr__(self):
13616 
    L = ['%s=%r' % (key, value)
13617 
      for key, value in self.__dict__.iteritems()]
13618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13619 
 
13620 
  def __eq__(self, other):
13621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13622 
 
13623 
  def __ne__(self, other):
13624 
    return not (self == other)
13625 
 
13626 
class getAllTags_result:
13627 
  """
13628 
  Attributes:
13629 
   - success
13630 
  """
13631 
 
13632 
  thrift_spec = (
13633 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13634 
  )
13635 
 
13636 
  def __init__(self, success=None,):
13637 
    self.success = success
13638 
 
13639 
  def read(self, iprot):
13640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13642 
      return
13643 
    iprot.readStructBegin()
13644 
    while True:
13645 
      (fname, ftype, fid) = iprot.readFieldBegin()
13646 
      if ftype == TType.STOP:
13647 
        break
13648 
      if fid == 0:
13649 
        if ftype == TType.LIST:
13650 
          self.success = []
8590 kshitij.so 13651 
          (_etype168, _size165) = iprot.readListBegin()
13652 
          for _i169 in xrange(_size165):
13653 
            _elem170 = iprot.readString();
13654 
            self.success.append(_elem170)
6512 kshitij.so 13655 
          iprot.readListEnd()
13656 
        else:
13657 
          iprot.skip(ftype)
13658 
      else:
13659 
        iprot.skip(ftype)
13660 
      iprot.readFieldEnd()
13661 
    iprot.readStructEnd()
13662 
 
13663 
  def write(self, oprot):
13664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13666 
      return
13667 
    oprot.writeStructBegin('getAllTags_result')
13668 
    if self.success is not None:
13669 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13670 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 13671 
      for iter171 in self.success:
13672 
        oprot.writeString(iter171)
6512 kshitij.so 13673 
      oprot.writeListEnd()
13674 
      oprot.writeFieldEnd()
13675 
    oprot.writeFieldStop()
13676 
    oprot.writeStructEnd()
13677 
 
13678 
  def validate(self):
13679 
    return
13680 
 
13681 
 
13682 
  def __repr__(self):
13683 
    L = ['%s=%r' % (key, value)
13684 
      for key, value in self.__dict__.iteritems()]
13685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13686 
 
13687 
  def __eq__(self, other):
13688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13689 
 
13690 
  def __ne__(self, other):
13691 
    return not (self == other)
13692 
 
13693 
class getAllEntitiesByTagName_args:
13694 
  """
13695 
  Attributes:
13696 
   - displayName
13697 
  """
13698 
 
13699 
  thrift_spec = (
13700 
    None, # 0
13701 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13702 
  )
13703 
 
13704 
  def __init__(self, displayName=None,):
13705 
    self.displayName = displayName
13706 
 
13707 
  def read(self, iprot):
13708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13710 
      return
13711 
    iprot.readStructBegin()
13712 
    while True:
13713 
      (fname, ftype, fid) = iprot.readFieldBegin()
13714 
      if ftype == TType.STOP:
13715 
        break
13716 
      if fid == 1:
13717 
        if ftype == TType.STRING:
13718 
          self.displayName = iprot.readString();
13719 
        else:
13720 
          iprot.skip(ftype)
13721 
      else:
13722 
        iprot.skip(ftype)
13723 
      iprot.readFieldEnd()
13724 
    iprot.readStructEnd()
13725 
 
13726 
  def write(self, oprot):
13727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13729 
      return
13730 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
13731 
    if self.displayName is not None:
13732 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13733 
      oprot.writeString(self.displayName)
13734 
      oprot.writeFieldEnd()
13735 
    oprot.writeFieldStop()
13736 
    oprot.writeStructEnd()
13737 
 
13738 
  def validate(self):
13739 
    return
13740 
 
13741 
 
13742 
  def __repr__(self):
13743 
    L = ['%s=%r' % (key, value)
13744 
      for key, value in self.__dict__.iteritems()]
13745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13746 
 
13747 
  def __eq__(self, other):
13748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13749 
 
13750 
  def __ne__(self, other):
13751 
    return not (self == other)
13752 
 
13753 
class getAllEntitiesByTagName_result:
13754 
  """
13755 
  Attributes:
13756 
   - success
13757 
  """
13758 
 
13759 
  thrift_spec = (
13760 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13761 
  )
13762 
 
13763 
  def __init__(self, success=None,):
13764 
    self.success = success
13765 
 
13766 
  def read(self, iprot):
13767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13769 
      return
13770 
    iprot.readStructBegin()
13771 
    while True:
13772 
      (fname, ftype, fid) = iprot.readFieldBegin()
13773 
      if ftype == TType.STOP:
13774 
        break
13775 
      if fid == 0:
13776 
        if ftype == TType.LIST:
13777 
          self.success = []
8590 kshitij.so 13778 
          (_etype175, _size172) = iprot.readListBegin()
13779 
          for _i176 in xrange(_size172):
13780 
            _elem177 = iprot.readI64();
13781 
            self.success.append(_elem177)
6512 kshitij.so 13782 
          iprot.readListEnd()
13783 
        else:
13784 
          iprot.skip(ftype)
13785 
      else:
13786 
        iprot.skip(ftype)
13787 
      iprot.readFieldEnd()
13788 
    iprot.readStructEnd()
13789 
 
13790 
  def write(self, oprot):
13791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13793 
      return
13794 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
13795 
    if self.success is not None:
13796 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13797 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 13798 
      for iter178 in self.success:
13799 
        oprot.writeI64(iter178)
6512 kshitij.so 13800 
      oprot.writeListEnd()
13801 
      oprot.writeFieldEnd()
13802 
    oprot.writeFieldStop()
13803 
    oprot.writeStructEnd()
13804 
 
13805 
  def validate(self):
13806 
    return
13807 
 
13808 
 
13809 
  def __repr__(self):
13810 
    L = ['%s=%r' % (key, value)
13811 
      for key, value in self.__dict__.iteritems()]
13812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13813 
 
13814 
  def __eq__(self, other):
13815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13816 
 
13817 
  def __ne__(self, other):
13818 
    return not (self == other)
13819 
 
6845 amit.gupta 13820 
class getAllEntityTags_args:
13821 
 
13822 
  thrift_spec = (
13823 
  )
13824 
 
13825 
  def read(self, iprot):
13826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13828 
      return
13829 
    iprot.readStructBegin()
13830 
    while True:
13831 
      (fname, ftype, fid) = iprot.readFieldBegin()
13832 
      if ftype == TType.STOP:
13833 
        break
13834 
      else:
13835 
        iprot.skip(ftype)
13836 
      iprot.readFieldEnd()
13837 
    iprot.readStructEnd()
13838 
 
13839 
  def write(self, oprot):
13840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13842 
      return
13843 
    oprot.writeStructBegin('getAllEntityTags_args')
13844 
    oprot.writeFieldStop()
13845 
    oprot.writeStructEnd()
13846 
 
13847 
  def validate(self):
13848 
    return
13849 
 
13850 
 
13851 
  def __repr__(self):
13852 
    L = ['%s=%r' % (key, value)
13853 
      for key, value in self.__dict__.iteritems()]
13854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13855 
 
13856 
  def __eq__(self, other):
13857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13858 
 
13859 
  def __ne__(self, other):
13860 
    return not (self == other)
13861 
 
13862 
class getAllEntityTags_result:
13863 
  """
13864 
  Attributes:
13865 
   - success
13866 
  """
13867 
 
13868 
  thrift_spec = (
13869 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
13870 
  )
13871 
 
13872 
  def __init__(self, success=None,):
13873 
    self.success = success
13874 
 
13875 
  def read(self, iprot):
13876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13878 
      return
13879 
    iprot.readStructBegin()
13880 
    while True:
13881 
      (fname, ftype, fid) = iprot.readFieldBegin()
13882 
      if ftype == TType.STOP:
13883 
        break
13884 
      if fid == 0:
13885 
        if ftype == TType.MAP:
13886 
          self.success = {}
8590 kshitij.so 13887 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
13888 
          for _i183 in xrange(_size179):
13889 
            _key184 = iprot.readI64();
13890 
            _val185 = []
13891 
            (_etype189, _size186) = iprot.readListBegin()
13892 
            for _i190 in xrange(_size186):
13893 
              _elem191 = iprot.readString();
13894 
              _val185.append(_elem191)
6845 amit.gupta 13895 
            iprot.readListEnd()
8590 kshitij.so 13896 
            self.success[_key184] = _val185
6845 amit.gupta 13897 
          iprot.readMapEnd()
13898 
        else:
13899 
          iprot.skip(ftype)
13900 
      else:
13901 
        iprot.skip(ftype)
13902 
      iprot.readFieldEnd()
13903 
    iprot.readStructEnd()
13904 
 
13905 
  def write(self, oprot):
13906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13908 
      return
13909 
    oprot.writeStructBegin('getAllEntityTags_result')
13910 
    if self.success is not None:
13911 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13912 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 13913 
      for kiter192,viter193 in self.success.items():
13914 
        oprot.writeI64(kiter192)
13915 
        oprot.writeListBegin(TType.STRING, len(viter193))
13916 
        for iter194 in viter193:
13917 
          oprot.writeString(iter194)
6845 amit.gupta 13918 
        oprot.writeListEnd()
13919 
      oprot.writeMapEnd()
13920 
      oprot.writeFieldEnd()
13921 
    oprot.writeFieldStop()
13922 
    oprot.writeStructEnd()
13923 
 
13924 
  def validate(self):
13925 
    return
13926 
 
13927 
 
13928 
  def __repr__(self):
13929 
    L = ['%s=%r' % (key, value)
13930 
      for key, value in self.__dict__.iteritems()]
13931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13932 
 
13933 
  def __eq__(self, other):
13934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13935 
 
13936 
  def __ne__(self, other):
13937 
    return not (self == other)
13938 
 
6850 kshitij.so 13939 
class addBanner_args:
13940 
  """
13941 
  Attributes:
8590 kshitij.so 13942 
   - bannerCongregate
6850 kshitij.so 13943 
  """
13944 
 
13945 
  thrift_spec = (
13946 
    None, # 0
8590 kshitij.so 13947 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 13948 
  )
13949 
 
8590 kshitij.so 13950 
  def __init__(self, bannerCongregate=None,):
13951 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 13952 
 
13953 
  def read(self, iprot):
13954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13956 
      return
13957 
    iprot.readStructBegin()
13958 
    while True:
13959 
      (fname, ftype, fid) = iprot.readFieldBegin()
13960 
      if ftype == TType.STOP:
13961 
        break
13962 
      if fid == 1:
8579 kshitij.so 13963 
        if ftype == TType.STRUCT:
8590 kshitij.so 13964 
          self.bannerCongregate = BannerCongregate()
13965 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 13966 
        else:
13967 
          iprot.skip(ftype)
8579 kshitij.so 13968 
      else:
13969 
        iprot.skip(ftype)
13970 
      iprot.readFieldEnd()
13971 
    iprot.readStructEnd()
13972 
 
13973 
  def write(self, oprot):
13974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13976 
      return
13977 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 13978 
    if self.bannerCongregate is not None:
13979 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
13980 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 13981 
      oprot.writeFieldEnd()
13982 
    oprot.writeFieldStop()
13983 
    oprot.writeStructEnd()
13984 
 
13985 
  def validate(self):
13986 
    return
13987 
 
13988 
 
13989 
  def __repr__(self):
13990 
    L = ['%s=%r' % (key, value)
13991 
      for key, value in self.__dict__.iteritems()]
13992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13993 
 
13994 
  def __eq__(self, other):
13995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13996 
 
13997 
  def __ne__(self, other):
13998 
    return not (self == other)
13999 
 
14000 
class addBanner_result:
10097 kshitij.so 14001 
  """
14002 
  Attributes:
14003 
   - success
14004 
  """
8579 kshitij.so 14005 
 
14006 
  thrift_spec = (
10097 kshitij.so 14007 
    (0, TType.BOOL, 'success', None, None, ), # 0
8579 kshitij.so 14008 
  )
14009 
 
10097 kshitij.so 14010 
  def __init__(self, success=None,):
14011 
    self.success = success
14012 
 
8579 kshitij.so 14013 
  def read(self, iprot):
14014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14016 
      return
14017 
    iprot.readStructBegin()
14018 
    while True:
14019 
      (fname, ftype, fid) = iprot.readFieldBegin()
14020 
      if ftype == TType.STOP:
14021 
        break
10097 kshitij.so 14022 
      if fid == 0:
14023 
        if ftype == TType.BOOL:
14024 
          self.success = iprot.readBool();
14025 
        else:
14026 
          iprot.skip(ftype)
8579 kshitij.so 14027 
      else:
14028 
        iprot.skip(ftype)
14029 
      iprot.readFieldEnd()
14030 
    iprot.readStructEnd()
14031 
 
14032 
  def write(self, oprot):
14033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14035 
      return
14036 
    oprot.writeStructBegin('addBanner_result')
10097 kshitij.so 14037 
    if self.success is not None:
14038 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14039 
      oprot.writeBool(self.success)
14040 
      oprot.writeFieldEnd()
8579 kshitij.so 14041 
    oprot.writeFieldStop()
14042 
    oprot.writeStructEnd()
14043 
 
14044 
  def validate(self):
14045 
    return
14046 
 
14047 
 
14048 
  def __repr__(self):
14049 
    L = ['%s=%r' % (key, value)
14050 
      for key, value in self.__dict__.iteritems()]
14051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14052 
 
14053 
  def __eq__(self, other):
14054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14055 
 
14056 
  def __ne__(self, other):
14057 
    return not (self == other)
14058 
 
14059 
class updateBanner_args:
14060 
  """
14061 
  Attributes:
14062 
   - banner
14063 
  """
14064 
 
14065 
  thrift_spec = (
14066 
    None, # 0
14067 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
14068 
  )
14069 
 
14070 
  def __init__(self, banner=None,):
14071 
    self.banner = banner
14072 
 
14073 
  def read(self, iprot):
14074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14076 
      return
14077 
    iprot.readStructBegin()
14078 
    while True:
14079 
      (fname, ftype, fid) = iprot.readFieldBegin()
14080 
      if ftype == TType.STOP:
14081 
        break
14082 
      if fid == 1:
14083 
        if ftype == TType.STRUCT:
14084 
          self.banner = Banner()
14085 
          self.banner.read(iprot)
6850 kshitij.so 14086 
        else:
14087 
          iprot.skip(ftype)
14088 
      else:
14089 
        iprot.skip(ftype)
14090 
      iprot.readFieldEnd()
14091 
    iprot.readStructEnd()
14092 
 
14093 
  def write(self, oprot):
14094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14096 
      return
8579 kshitij.so 14097 
    oprot.writeStructBegin('updateBanner_args')
14098 
    if self.banner is not None:
14099 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
14100 
      self.banner.write(oprot)
6850 kshitij.so 14101 
      oprot.writeFieldEnd()
14102 
    oprot.writeFieldStop()
14103 
    oprot.writeStructEnd()
14104 
 
14105 
  def validate(self):
14106 
    return
14107 
 
14108 
 
14109 
  def __repr__(self):
14110 
    L = ['%s=%r' % (key, value)
14111 
      for key, value in self.__dict__.iteritems()]
14112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14113 
 
14114 
  def __eq__(self, other):
14115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14116 
 
14117 
  def __ne__(self, other):
14118 
    return not (self == other)
14119 
 
8579 kshitij.so 14120 
class updateBanner_result:
6850 kshitij.so 14121 
  """
14122 
  Attributes:
14123 
   - success
14124 
  """
14125 
 
14126 
  thrift_spec = (
14127 
    (0, TType.BOOL, 'success', None, None, ), # 0
14128 
  )
14129 
 
14130 
  def __init__(self, success=None,):
14131 
    self.success = success
14132 
 
14133 
  def read(self, iprot):
14134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14136 
      return
14137 
    iprot.readStructBegin()
14138 
    while True:
14139 
      (fname, ftype, fid) = iprot.readFieldBegin()
14140 
      if ftype == TType.STOP:
14141 
        break
14142 
      if fid == 0:
14143 
        if ftype == TType.BOOL:
14144 
          self.success = iprot.readBool();
14145 
        else:
14146 
          iprot.skip(ftype)
14147 
      else:
14148 
        iprot.skip(ftype)
14149 
      iprot.readFieldEnd()
14150 
    iprot.readStructEnd()
14151 
 
14152 
  def write(self, oprot):
14153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14155 
      return
8579 kshitij.so 14156 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 14157 
    if self.success is not None:
14158 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14159 
      oprot.writeBool(self.success)
14160 
      oprot.writeFieldEnd()
14161 
    oprot.writeFieldStop()
14162 
    oprot.writeStructEnd()
14163 
 
14164 
  def validate(self):
14165 
    return
14166 
 
14167 
 
14168 
  def __repr__(self):
14169 
    L = ['%s=%r' % (key, value)
14170 
      for key, value in self.__dict__.iteritems()]
14171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14172 
 
14173 
  def __eq__(self, other):
14174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14175 
 
14176 
  def __ne__(self, other):
14177 
    return not (self == other)
14178 
 
14179 
class getAllBanners_args:
14180 
 
14181 
  thrift_spec = (
14182 
  )
14183 
 
14184 
  def read(self, iprot):
14185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14187 
      return
14188 
    iprot.readStructBegin()
14189 
    while True:
14190 
      (fname, ftype, fid) = iprot.readFieldBegin()
14191 
      if ftype == TType.STOP:
14192 
        break
14193 
      else:
14194 
        iprot.skip(ftype)
14195 
      iprot.readFieldEnd()
14196 
    iprot.readStructEnd()
14197 
 
14198 
  def write(self, oprot):
14199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14201 
      return
14202 
    oprot.writeStructBegin('getAllBanners_args')
14203 
    oprot.writeFieldStop()
14204 
    oprot.writeStructEnd()
14205 
 
14206 
  def validate(self):
14207 
    return
14208 
 
14209 
 
14210 
  def __repr__(self):
14211 
    L = ['%s=%r' % (key, value)
14212 
      for key, value in self.__dict__.iteritems()]
14213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14214 
 
14215 
  def __eq__(self, other):
14216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14217 
 
14218 
  def __ne__(self, other):
14219 
    return not (self == other)
14220 
 
14221 
class getAllBanners_result:
14222 
  """
14223 
  Attributes:
14224 
   - success
14225 
  """
14226 
 
14227 
  thrift_spec = (
8579 kshitij.so 14228 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 14229 
  )
14230 
 
14231 
  def __init__(self, success=None,):
14232 
    self.success = success
14233 
 
14234 
  def read(self, iprot):
14235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14237 
      return
14238 
    iprot.readStructBegin()
14239 
    while True:
14240 
      (fname, ftype, fid) = iprot.readFieldBegin()
14241 
      if ftype == TType.STOP:
14242 
        break
14243 
      if fid == 0:
14244 
        if ftype == TType.LIST:
14245 
          self.success = []
8590 kshitij.so 14246 
          (_etype198, _size195) = iprot.readListBegin()
14247 
          for _i199 in xrange(_size195):
14248 
            _elem200 = Banner()
14249 
            _elem200.read(iprot)
14250 
            self.success.append(_elem200)
6850 kshitij.so 14251 
          iprot.readListEnd()
14252 
        else:
14253 
          iprot.skip(ftype)
14254 
      else:
14255 
        iprot.skip(ftype)
14256 
      iprot.readFieldEnd()
14257 
    iprot.readStructEnd()
14258 
 
14259 
  def write(self, oprot):
14260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14262 
      return
14263 
    oprot.writeStructBegin('getAllBanners_result')
14264 
    if self.success is not None:
14265 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 14266 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14267 
      for iter201 in self.success:
14268 
        iter201.write(oprot)
6850 kshitij.so 14269 
      oprot.writeListEnd()
14270 
      oprot.writeFieldEnd()
14271 
    oprot.writeFieldStop()
14272 
    oprot.writeStructEnd()
14273 
 
14274 
  def validate(self):
14275 
    return
14276 
 
14277 
 
14278 
  def __repr__(self):
14279 
    L = ['%s=%r' % (key, value)
14280 
      for key, value in self.__dict__.iteritems()]
14281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14282 
 
14283 
  def __eq__(self, other):
14284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14285 
 
14286 
  def __ne__(self, other):
14287 
    return not (self == other)
14288 
 
14289 
class deleteBanner_args:
14290 
  """
14291 
  Attributes:
14292 
   - bannerName
9155 kshitij.so 14293 
   - bannerType
6850 kshitij.so 14294 
  """
14295 
 
14296 
  thrift_spec = (
14297 
    None, # 0
14298 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14299 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 14300 
  )
14301 
 
9155 kshitij.so 14302 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 14303 
    self.bannerName = bannerName
9155 kshitij.so 14304 
    self.bannerType = bannerType
6850 kshitij.so 14305 
 
14306 
  def read(self, iprot):
14307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14309 
      return
14310 
    iprot.readStructBegin()
14311 
    while True:
14312 
      (fname, ftype, fid) = iprot.readFieldBegin()
14313 
      if ftype == TType.STOP:
14314 
        break
14315 
      if fid == 1:
14316 
        if ftype == TType.STRING:
14317 
          self.bannerName = iprot.readString();
14318 
        else:
14319 
          iprot.skip(ftype)
9155 kshitij.so 14320 
      elif fid == 2:
14321 
        if ftype == TType.I32:
14322 
          self.bannerType = iprot.readI32();
14323 
        else:
14324 
          iprot.skip(ftype)
6850 kshitij.so 14325 
      else:
14326 
        iprot.skip(ftype)
14327 
      iprot.readFieldEnd()
14328 
    iprot.readStructEnd()
14329 
 
14330 
  def write(self, oprot):
14331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14333 
      return
14334 
    oprot.writeStructBegin('deleteBanner_args')
14335 
    if self.bannerName is not None:
14336 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14337 
      oprot.writeString(self.bannerName)
14338 
      oprot.writeFieldEnd()
9155 kshitij.so 14339 
    if self.bannerType is not None:
14340 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14341 
      oprot.writeI32(self.bannerType)
14342 
      oprot.writeFieldEnd()
6850 kshitij.so 14343 
    oprot.writeFieldStop()
14344 
    oprot.writeStructEnd()
14345 
 
14346 
  def validate(self):
14347 
    return
14348 
 
14349 
 
14350 
  def __repr__(self):
14351 
    L = ['%s=%r' % (key, value)
14352 
      for key, value in self.__dict__.iteritems()]
14353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14354 
 
14355 
  def __eq__(self, other):
14356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14357 
 
14358 
  def __ne__(self, other):
14359 
    return not (self == other)
14360 
 
14361 
class deleteBanner_result:
14362 
  """
14363 
  Attributes:
14364 
   - success
14365 
  """
14366 
 
14367 
  thrift_spec = (
14368 
    (0, TType.BOOL, 'success', None, None, ), # 0
14369 
  )
14370 
 
14371 
  def __init__(self, success=None,):
14372 
    self.success = success
14373 
 
14374 
  def read(self, iprot):
14375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14377 
      return
14378 
    iprot.readStructBegin()
14379 
    while True:
14380 
      (fname, ftype, fid) = iprot.readFieldBegin()
14381 
      if ftype == TType.STOP:
14382 
        break
14383 
      if fid == 0:
14384 
        if ftype == TType.BOOL:
14385 
          self.success = iprot.readBool();
14386 
        else:
14387 
          iprot.skip(ftype)
14388 
      else:
14389 
        iprot.skip(ftype)
14390 
      iprot.readFieldEnd()
14391 
    iprot.readStructEnd()
14392 
 
14393 
  def write(self, oprot):
14394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14396 
      return
14397 
    oprot.writeStructBegin('deleteBanner_result')
14398 
    if self.success is not None:
14399 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14400 
      oprot.writeBool(self.success)
14401 
      oprot.writeFieldEnd()
14402 
    oprot.writeFieldStop()
14403 
    oprot.writeStructEnd()
14404 
 
14405 
  def validate(self):
14406 
    return
14407 
 
14408 
 
14409 
  def __repr__(self):
14410 
    L = ['%s=%r' % (key, value)
14411 
      for key, value in self.__dict__.iteritems()]
14412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14413 
 
14414 
  def __eq__(self, other):
14415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14416 
 
14417 
  def __ne__(self, other):
14418 
    return not (self == other)
14419 
 
14420 
class getBannerDetails_args:
14421 
  """
14422 
  Attributes:
14423 
   - bannerName
9155 kshitij.so 14424 
   - bannerType
6850 kshitij.so 14425 
  """
14426 
 
14427 
  thrift_spec = (
14428 
    None, # 0
14429 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14430 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 14431 
  )
14432 
 
9155 kshitij.so 14433 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 14434 
    self.bannerName = bannerName
9155 kshitij.so 14435 
    self.bannerType = bannerType
6850 kshitij.so 14436 
 
14437 
  def read(self, iprot):
14438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14440 
      return
14441 
    iprot.readStructBegin()
14442 
    while True:
14443 
      (fname, ftype, fid) = iprot.readFieldBegin()
14444 
      if ftype == TType.STOP:
14445 
        break
14446 
      if fid == 1:
14447 
        if ftype == TType.STRING:
14448 
          self.bannerName = iprot.readString();
14449 
        else:
14450 
          iprot.skip(ftype)
9155 kshitij.so 14451 
      elif fid == 2:
14452 
        if ftype == TType.I32:
14453 
          self.bannerType = iprot.readI32();
14454 
        else:
14455 
          iprot.skip(ftype)
6850 kshitij.so 14456 
      else:
14457 
        iprot.skip(ftype)
14458 
      iprot.readFieldEnd()
14459 
    iprot.readStructEnd()
14460 
 
14461 
  def write(self, oprot):
14462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14464 
      return
14465 
    oprot.writeStructBegin('getBannerDetails_args')
14466 
    if self.bannerName is not None:
14467 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14468 
      oprot.writeString(self.bannerName)
14469 
      oprot.writeFieldEnd()
9155 kshitij.so 14470 
    if self.bannerType is not None:
14471 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14472 
      oprot.writeI32(self.bannerType)
14473 
      oprot.writeFieldEnd()
6850 kshitij.so 14474 
    oprot.writeFieldStop()
14475 
    oprot.writeStructEnd()
14476 
 
14477 
  def validate(self):
14478 
    return
14479 
 
14480 
 
14481 
  def __repr__(self):
14482 
    L = ['%s=%r' % (key, value)
14483 
      for key, value in self.__dict__.iteritems()]
14484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14485 
 
14486 
  def __eq__(self, other):
14487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14488 
 
14489 
  def __ne__(self, other):
14490 
    return not (self == other)
14491 
 
14492 
class getBannerDetails_result:
14493 
  """
14494 
  Attributes:
14495 
   - success
14496 
  """
14497 
 
14498 
  thrift_spec = (
14499 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
14500 
  )
14501 
 
14502 
  def __init__(self, success=None,):
14503 
    self.success = success
14504 
 
14505 
  def read(self, iprot):
14506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14508 
      return
14509 
    iprot.readStructBegin()
14510 
    while True:
14511 
      (fname, ftype, fid) = iprot.readFieldBegin()
14512 
      if ftype == TType.STOP:
14513 
        break
14514 
      if fid == 0:
14515 
        if ftype == TType.STRUCT:
14516 
          self.success = Banner()
14517 
          self.success.read(iprot)
14518 
        else:
14519 
          iprot.skip(ftype)
14520 
      else:
14521 
        iprot.skip(ftype)
14522 
      iprot.readFieldEnd()
14523 
    iprot.readStructEnd()
14524 
 
14525 
  def write(self, oprot):
14526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14528 
      return
14529 
    oprot.writeStructBegin('getBannerDetails_result')
14530 
    if self.success is not None:
14531 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14532 
      self.success.write(oprot)
14533 
      oprot.writeFieldEnd()
14534 
    oprot.writeFieldStop()
14535 
    oprot.writeStructEnd()
14536 
 
14537 
  def validate(self):
14538 
    return
14539 
 
14540 
 
14541 
  def __repr__(self):
14542 
    L = ['%s=%r' % (key, value)
14543 
      for key, value in self.__dict__.iteritems()]
14544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14545 
 
14546 
  def __eq__(self, other):
14547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14548 
 
14549 
  def __ne__(self, other):
14550 
    return not (self == other)
14551 
 
14552 
class getActiveBanners_args:
14553 
 
14554 
  thrift_spec = (
14555 
  )
14556 
 
14557 
  def read(self, iprot):
14558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14560 
      return
14561 
    iprot.readStructBegin()
14562 
    while True:
14563 
      (fname, ftype, fid) = iprot.readFieldBegin()
14564 
      if ftype == TType.STOP:
14565 
        break
14566 
      else:
14567 
        iprot.skip(ftype)
14568 
      iprot.readFieldEnd()
14569 
    iprot.readStructEnd()
14570 
 
14571 
  def write(self, oprot):
14572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14574 
      return
14575 
    oprot.writeStructBegin('getActiveBanners_args')
14576 
    oprot.writeFieldStop()
14577 
    oprot.writeStructEnd()
14578 
 
14579 
  def validate(self):
14580 
    return
14581 
 
14582 
 
14583 
  def __repr__(self):
14584 
    L = ['%s=%r' % (key, value)
14585 
      for key, value in self.__dict__.iteritems()]
14586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14587 
 
14588 
  def __eq__(self, other):
14589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14590 
 
14591 
  def __ne__(self, other):
14592 
    return not (self == other)
14593 
 
14594 
class getActiveBanners_result:
14595 
  """
14596 
  Attributes:
14597 
   - success
14598 
  """
14599 
 
14600 
  thrift_spec = (
8579 kshitij.so 14601 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 14602 
  )
14603 
 
14604 
  def __init__(self, success=None,):
14605 
    self.success = success
14606 
 
14607 
  def read(self, iprot):
14608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14610 
      return
14611 
    iprot.readStructBegin()
14612 
    while True:
14613 
      (fname, ftype, fid) = iprot.readFieldBegin()
14614 
      if ftype == TType.STOP:
14615 
        break
14616 
      if fid == 0:
8579 kshitij.so 14617 
        if ftype == TType.MAP:
14618 
          self.success = {}
8590 kshitij.so 14619 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
14620 
          for _i206 in xrange(_size202):
14621 
            _key207 = iprot.readString();
14622 
            _val208 = []
14623 
            (_etype212, _size209) = iprot.readListBegin()
14624 
            for _i213 in xrange(_size209):
14625 
              _elem214 = Banner()
14626 
              _elem214.read(iprot)
14627 
              _val208.append(_elem214)
8579 kshitij.so 14628 
            iprot.readListEnd()
8590 kshitij.so 14629 
            self.success[_key207] = _val208
8579 kshitij.so 14630 
          iprot.readMapEnd()
6850 kshitij.so 14631 
        else:
14632 
          iprot.skip(ftype)
14633 
      else:
14634 
        iprot.skip(ftype)
14635 
      iprot.readFieldEnd()
14636 
    iprot.readStructEnd()
14637 
 
14638 
  def write(self, oprot):
14639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14641 
      return
14642 
    oprot.writeStructBegin('getActiveBanners_result')
14643 
    if self.success is not None:
8579 kshitij.so 14644 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14645 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 14646 
      for kiter215,viter216 in self.success.items():
14647 
        oprot.writeString(kiter215)
14648 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
14649 
        for iter217 in viter216:
14650 
          iter217.write(oprot)
8579 kshitij.so 14651 
        oprot.writeListEnd()
14652 
      oprot.writeMapEnd()
6850 kshitij.so 14653 
      oprot.writeFieldEnd()
14654 
    oprot.writeFieldStop()
14655 
    oprot.writeStructEnd()
14656 
 
14657 
  def validate(self):
14658 
    return
14659 
 
14660 
 
14661 
  def __repr__(self):
14662 
    L = ['%s=%r' % (key, value)
14663 
      for key, value in self.__dict__.iteritems()]
14664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14665 
 
14666 
  def __eq__(self, other):
14667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14668 
 
14669 
  def __ne__(self, other):
14670 
    return not (self == other)
14671 
 
6849 kshitij.so 14672 
class addBannerMap_args:
14673 
  """
14674 
  Attributes:
8579 kshitij.so 14675 
   - bannerMaps
6849 kshitij.so 14676 
  """
14677 
 
14678 
  thrift_spec = (
14679 
    None, # 0
8579 kshitij.so 14680 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 14681 
  )
14682 
 
8579 kshitij.so 14683 
  def __init__(self, bannerMaps=None,):
14684 
    self.bannerMaps = bannerMaps
6849 kshitij.so 14685 
 
14686 
  def read(self, iprot):
14687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14689 
      return
14690 
    iprot.readStructBegin()
14691 
    while True:
14692 
      (fname, ftype, fid) = iprot.readFieldBegin()
14693 
      if ftype == TType.STOP:
14694 
        break
14695 
      if fid == 1:
8579 kshitij.so 14696 
        if ftype == TType.LIST:
14697 
          self.bannerMaps = []
8590 kshitij.so 14698 
          (_etype221, _size218) = iprot.readListBegin()
14699 
          for _i222 in xrange(_size218):
14700 
            _elem223 = BannerMap()
14701 
            _elem223.read(iprot)
14702 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 14703 
          iprot.readListEnd()
6849 kshitij.so 14704 
        else:
14705 
          iprot.skip(ftype)
8579 kshitij.so 14706 
      else:
14707 
        iprot.skip(ftype)
14708 
      iprot.readFieldEnd()
14709 
    iprot.readStructEnd()
14710 
 
14711 
  def write(self, oprot):
14712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14714 
      return
14715 
    oprot.writeStructBegin('addBannerMap_args')
14716 
    if self.bannerMaps is not None:
14717 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
14718 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 14719 
      for iter224 in self.bannerMaps:
14720 
        iter224.write(oprot)
8579 kshitij.so 14721 
      oprot.writeListEnd()
14722 
      oprot.writeFieldEnd()
14723 
    oprot.writeFieldStop()
14724 
    oprot.writeStructEnd()
14725 
 
14726 
  def validate(self):
14727 
    return
14728 
 
14729 
 
14730 
  def __repr__(self):
14731 
    L = ['%s=%r' % (key, value)
14732 
      for key, value in self.__dict__.iteritems()]
14733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14734 
 
14735 
  def __eq__(self, other):
14736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14737 
 
14738 
  def __ne__(self, other):
14739 
    return not (self == other)
14740 
 
14741 
class addBannerMap_result:
14742 
  """
14743 
  Attributes:
14744 
   - success
14745 
  """
14746 
 
14747 
  thrift_spec = (
14748 
    (0, TType.BOOL, 'success', None, None, ), # 0
14749 
  )
14750 
 
14751 
  def __init__(self, success=None,):
14752 
    self.success = success
14753 
 
14754 
  def read(self, iprot):
14755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14757 
      return
14758 
    iprot.readStructBegin()
14759 
    while True:
14760 
      (fname, ftype, fid) = iprot.readFieldBegin()
14761 
      if ftype == TType.STOP:
14762 
        break
14763 
      if fid == 0:
14764 
        if ftype == TType.BOOL:
14765 
          self.success = iprot.readBool();
6849 kshitij.so 14766 
        else:
14767 
          iprot.skip(ftype)
8579 kshitij.so 14768 
      else:
14769 
        iprot.skip(ftype)
14770 
      iprot.readFieldEnd()
14771 
    iprot.readStructEnd()
14772 
 
14773 
  def write(self, oprot):
14774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14776 
      return
14777 
    oprot.writeStructBegin('addBannerMap_result')
14778 
    if self.success is not None:
14779 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14780 
      oprot.writeBool(self.success)
14781 
      oprot.writeFieldEnd()
14782 
    oprot.writeFieldStop()
14783 
    oprot.writeStructEnd()
14784 
 
14785 
  def validate(self):
14786 
    return
14787 
 
14788 
 
14789 
  def __repr__(self):
14790 
    L = ['%s=%r' % (key, value)
14791 
      for key, value in self.__dict__.iteritems()]
14792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14793 
 
14794 
  def __eq__(self, other):
14795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14796 
 
14797 
  def __ne__(self, other):
14798 
    return not (self == other)
14799 
 
14800 
class updateBannerMap_args:
14801 
  """
14802 
  Attributes:
14803 
   - bannerMap
14804 
  """
14805 
 
14806 
  thrift_spec = (
14807 
    None, # 0
14808 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
14809 
  )
14810 
 
14811 
  def __init__(self, bannerMap=None,):
14812 
    self.bannerMap = bannerMap
14813 
 
14814 
  def read(self, iprot):
14815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14817 
      return
14818 
    iprot.readStructBegin()
14819 
    while True:
14820 
      (fname, ftype, fid) = iprot.readFieldBegin()
14821 
      if ftype == TType.STOP:
14822 
        break
14823 
      if fid == 1:
14824 
        if ftype == TType.STRUCT:
14825 
          self.bannerMap = BannerMap()
14826 
          self.bannerMap.read(iprot)
6849 kshitij.so 14827 
        else:
14828 
          iprot.skip(ftype)
14829 
      else:
14830 
        iprot.skip(ftype)
14831 
      iprot.readFieldEnd()
14832 
    iprot.readStructEnd()
14833 
 
14834 
  def write(self, oprot):
14835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14837 
      return
8579 kshitij.so 14838 
    oprot.writeStructBegin('updateBannerMap_args')
14839 
    if self.bannerMap is not None:
14840 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
14841 
      self.bannerMap.write(oprot)
6849 kshitij.so 14842 
      oprot.writeFieldEnd()
14843 
    oprot.writeFieldStop()
14844 
    oprot.writeStructEnd()
14845 
 
14846 
  def validate(self):
14847 
    return
14848 
 
14849 
 
14850 
  def __repr__(self):
14851 
    L = ['%s=%r' % (key, value)
14852 
      for key, value in self.__dict__.iteritems()]
14853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14854 
 
14855 
  def __eq__(self, other):
14856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14857 
 
14858 
  def __ne__(self, other):
14859 
    return not (self == other)
14860 
 
8579 kshitij.so 14861 
class updateBannerMap_result:
6849 kshitij.so 14862 
  """
14863 
  Attributes:
14864 
   - success
14865 
  """
14866 
 
14867 
  thrift_spec = (
14868 
    (0, TType.BOOL, 'success', None, None, ), # 0
14869 
  )
14870 
 
14871 
  def __init__(self, success=None,):
14872 
    self.success = success
14873 
 
14874 
  def read(self, iprot):
14875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14877 
      return
14878 
    iprot.readStructBegin()
14879 
    while True:
14880 
      (fname, ftype, fid) = iprot.readFieldBegin()
14881 
      if ftype == TType.STOP:
14882 
        break
14883 
      if fid == 0:
14884 
        if ftype == TType.BOOL:
14885 
          self.success = iprot.readBool();
14886 
        else:
14887 
          iprot.skip(ftype)
14888 
      else:
14889 
        iprot.skip(ftype)
14890 
      iprot.readFieldEnd()
14891 
    iprot.readStructEnd()
14892 
 
14893 
  def write(self, oprot):
14894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14896 
      return
8579 kshitij.so 14897 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 14898 
    if self.success is not None:
14899 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14900 
      oprot.writeBool(self.success)
14901 
      oprot.writeFieldEnd()
14902 
    oprot.writeFieldStop()
14903 
    oprot.writeStructEnd()
14904 
 
14905 
  def validate(self):
14906 
    return
14907 
 
14908 
 
14909 
  def __repr__(self):
14910 
    L = ['%s=%r' % (key, value)
14911 
      for key, value in self.__dict__.iteritems()]
14912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14913 
 
14914 
  def __eq__(self, other):
14915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14916 
 
14917 
  def __ne__(self, other):
14918 
    return not (self == other)
14919 
 
14920 
class deleteBannerMap_args:
14921 
  """
14922 
  Attributes:
14923 
   - bannerName
14924 
  """
14925 
 
14926 
  thrift_spec = (
14927 
    None, # 0
14928 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
14929 
  )
14930 
 
14931 
  def __init__(self, bannerName=None,):
14932 
    self.bannerName = bannerName
14933 
 
14934 
  def read(self, iprot):
14935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14937 
      return
14938 
    iprot.readStructBegin()
14939 
    while True:
14940 
      (fname, ftype, fid) = iprot.readFieldBegin()
14941 
      if ftype == TType.STOP:
14942 
        break
14943 
      if fid == 1:
14944 
        if ftype == TType.STRING:
14945 
          self.bannerName = iprot.readString();
14946 
        else:
14947 
          iprot.skip(ftype)
14948 
      else:
14949 
        iprot.skip(ftype)
14950 
      iprot.readFieldEnd()
14951 
    iprot.readStructEnd()
14952 
 
14953 
  def write(self, oprot):
14954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14956 
      return
14957 
    oprot.writeStructBegin('deleteBannerMap_args')
14958 
    if self.bannerName is not None:
14959 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14960 
      oprot.writeString(self.bannerName)
14961 
      oprot.writeFieldEnd()
14962 
    oprot.writeFieldStop()
14963 
    oprot.writeStructEnd()
14964 
 
14965 
  def validate(self):
14966 
    return
14967 
 
14968 
 
14969 
  def __repr__(self):
14970 
    L = ['%s=%r' % (key, value)
14971 
      for key, value in self.__dict__.iteritems()]
14972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14973 
 
14974 
  def __eq__(self, other):
14975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14976 
 
14977 
  def __ne__(self, other):
14978 
    return not (self == other)
14979 
 
14980 
class deleteBannerMap_result:
14981 
  """
14982 
  Attributes:
14983 
   - success
14984 
  """
14985 
 
14986 
  thrift_spec = (
14987 
    (0, TType.BOOL, 'success', None, None, ), # 0
14988 
  )
14989 
 
14990 
  def __init__(self, success=None,):
14991 
    self.success = success
14992 
 
14993 
  def read(self, iprot):
14994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14996 
      return
14997 
    iprot.readStructBegin()
14998 
    while True:
14999 
      (fname, ftype, fid) = iprot.readFieldBegin()
15000 
      if ftype == TType.STOP:
15001 
        break
15002 
      if fid == 0:
15003 
        if ftype == TType.BOOL:
15004 
          self.success = iprot.readBool();
15005 
        else:
15006 
          iprot.skip(ftype)
15007 
      else:
15008 
        iprot.skip(ftype)
15009 
      iprot.readFieldEnd()
15010 
    iprot.readStructEnd()
15011 
 
15012 
  def write(self, oprot):
15013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15015 
      return
15016 
    oprot.writeStructBegin('deleteBannerMap_result')
15017 
    if self.success is not None:
15018 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15019 
      oprot.writeBool(self.success)
15020 
      oprot.writeFieldEnd()
15021 
    oprot.writeFieldStop()
15022 
    oprot.writeStructEnd()
15023 
 
15024 
  def validate(self):
15025 
    return
15026 
 
15027 
 
15028 
  def __repr__(self):
15029 
    L = ['%s=%r' % (key, value)
15030 
      for key, value in self.__dict__.iteritems()]
15031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15032 
 
15033 
  def __eq__(self, other):
15034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15035 
 
15036 
  def __ne__(self, other):
15037 
    return not (self == other)
15038 
 
15039 
class getBannerMapDetails_args:
15040 
  """
15041 
  Attributes:
15042 
   - bannerName
9155 kshitij.so 15043 
   - bannerType
6849 kshitij.so 15044 
  """
15045 
 
15046 
  thrift_spec = (
15047 
    None, # 0
15048 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 15049 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 15050 
  )
15051 
 
9155 kshitij.so 15052 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 15053 
    self.bannerName = bannerName
9155 kshitij.so 15054 
    self.bannerType = bannerType
6849 kshitij.so 15055 
 
15056 
  def read(self, iprot):
15057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15059 
      return
15060 
    iprot.readStructBegin()
15061 
    while True:
15062 
      (fname, ftype, fid) = iprot.readFieldBegin()
15063 
      if ftype == TType.STOP:
15064 
        break
15065 
      if fid == 1:
15066 
        if ftype == TType.STRING:
15067 
          self.bannerName = iprot.readString();
15068 
        else:
15069 
          iprot.skip(ftype)
9155 kshitij.so 15070 
      elif fid == 2:
15071 
        if ftype == TType.I32:
15072 
          self.bannerType = iprot.readI32();
15073 
        else:
15074 
          iprot.skip(ftype)
6849 kshitij.so 15075 
      else:
15076 
        iprot.skip(ftype)
15077 
      iprot.readFieldEnd()
15078 
    iprot.readStructEnd()
15079 
 
15080 
  def write(self, oprot):
15081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15083 
      return
15084 
    oprot.writeStructBegin('getBannerMapDetails_args')
15085 
    if self.bannerName is not None:
15086 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
15087 
      oprot.writeString(self.bannerName)
15088 
      oprot.writeFieldEnd()
9155 kshitij.so 15089 
    if self.bannerType is not None:
15090 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
15091 
      oprot.writeI32(self.bannerType)
15092 
      oprot.writeFieldEnd()
6849 kshitij.so 15093 
    oprot.writeFieldStop()
15094 
    oprot.writeStructEnd()
15095 
 
15096 
  def validate(self):
15097 
    return
15098 
 
15099 
 
15100 
  def __repr__(self):
15101 
    L = ['%s=%r' % (key, value)
15102 
      for key, value in self.__dict__.iteritems()]
15103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15104 
 
15105 
  def __eq__(self, other):
15106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15107 
 
15108 
  def __ne__(self, other):
15109 
    return not (self == other)
15110 
 
15111 
class getBannerMapDetails_result:
15112 
  """
15113 
  Attributes:
15114 
   - success
15115 
  """
15116 
 
15117 
  thrift_spec = (
15118 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
15119 
  )
15120 
 
15121 
  def __init__(self, success=None,):
15122 
    self.success = success
15123 
 
15124 
  def read(self, iprot):
15125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15127 
      return
15128 
    iprot.readStructBegin()
15129 
    while True:
15130 
      (fname, ftype, fid) = iprot.readFieldBegin()
15131 
      if ftype == TType.STOP:
15132 
        break
15133 
      if fid == 0:
15134 
        if ftype == TType.LIST:
15135 
          self.success = []
8590 kshitij.so 15136 
          (_etype228, _size225) = iprot.readListBegin()
15137 
          for _i229 in xrange(_size225):
15138 
            _elem230 = BannerMap()
15139 
            _elem230.read(iprot)
15140 
            self.success.append(_elem230)
6849 kshitij.so 15141 
          iprot.readListEnd()
15142 
        else:
15143 
          iprot.skip(ftype)
15144 
      else:
15145 
        iprot.skip(ftype)
15146 
      iprot.readFieldEnd()
15147 
    iprot.readStructEnd()
15148 
 
15149 
  def write(self, oprot):
15150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15152 
      return
15153 
    oprot.writeStructBegin('getBannerMapDetails_result')
15154 
    if self.success is not None:
15155 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15156 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15157 
      for iter231 in self.success:
15158 
        iter231.write(oprot)
6849 kshitij.so 15159 
      oprot.writeListEnd()
15160 
      oprot.writeFieldEnd()
15161 
    oprot.writeFieldStop()
15162 
    oprot.writeStructEnd()
15163 
 
15164 
  def validate(self):
15165 
    return
15166 
 
15167 
 
15168 
  def __repr__(self):
15169 
    L = ['%s=%r' % (key, value)
15170 
      for key, value in self.__dict__.iteritems()]
15171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15172 
 
15173 
  def __eq__(self, other):
15174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15175 
 
15176 
  def __ne__(self, other):
15177 
    return not (self == other)
15178 
 
8579 kshitij.so 15179 
class addBannerUri_args:
15180 
  """
15181 
  Attributes:
15182 
   - bannerUriMappings
15183 
  """
15184 
 
15185 
  thrift_spec = (
15186 
    None, # 0
15187 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
15188 
  )
15189 
 
15190 
  def __init__(self, bannerUriMappings=None,):
15191 
    self.bannerUriMappings = bannerUriMappings
15192 
 
15193 
  def read(self, iprot):
15194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15196 
      return
15197 
    iprot.readStructBegin()
15198 
    while True:
15199 
      (fname, ftype, fid) = iprot.readFieldBegin()
15200 
      if ftype == TType.STOP:
15201 
        break
15202 
      if fid == 1:
15203 
        if ftype == TType.LIST:
15204 
          self.bannerUriMappings = []
8590 kshitij.so 15205 
          (_etype235, _size232) = iprot.readListBegin()
15206 
          for _i236 in xrange(_size232):
15207 
            _elem237 = BannerUriMapping()
15208 
            _elem237.read(iprot)
15209 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 15210 
          iprot.readListEnd()
15211 
        else:
15212 
          iprot.skip(ftype)
15213 
      else:
15214 
        iprot.skip(ftype)
15215 
      iprot.readFieldEnd()
15216 
    iprot.readStructEnd()
15217 
 
15218 
  def write(self, oprot):
15219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15221 
      return
15222 
    oprot.writeStructBegin('addBannerUri_args')
15223 
    if self.bannerUriMappings is not None:
15224 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
15225 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 15226 
      for iter238 in self.bannerUriMappings:
15227 
        iter238.write(oprot)
8579 kshitij.so 15228 
      oprot.writeListEnd()
15229 
      oprot.writeFieldEnd()
15230 
    oprot.writeFieldStop()
15231 
    oprot.writeStructEnd()
15232 
 
15233 
  def validate(self):
15234 
    return
15235 
 
15236 
 
15237 
  def __repr__(self):
15238 
    L = ['%s=%r' % (key, value)
15239 
      for key, value in self.__dict__.iteritems()]
15240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15241 
 
15242 
  def __eq__(self, other):
15243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15244 
 
15245 
  def __ne__(self, other):
15246 
    return not (self == other)
15247 
 
15248 
class addBannerUri_result:
15249 
 
15250 
  thrift_spec = (
15251 
  )
15252 
 
15253 
  def read(self, iprot):
15254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15256 
      return
15257 
    iprot.readStructBegin()
15258 
    while True:
15259 
      (fname, ftype, fid) = iprot.readFieldBegin()
15260 
      if ftype == TType.STOP:
15261 
        break
15262 
      else:
15263 
        iprot.skip(ftype)
15264 
      iprot.readFieldEnd()
15265 
    iprot.readStructEnd()
15266 
 
15267 
  def write(self, oprot):
15268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15270 
      return
15271 
    oprot.writeStructBegin('addBannerUri_result')
15272 
    oprot.writeFieldStop()
15273 
    oprot.writeStructEnd()
15274 
 
15275 
  def validate(self):
15276 
    return
15277 
 
15278 
 
15279 
  def __repr__(self):
15280 
    L = ['%s=%r' % (key, value)
15281 
      for key, value in self.__dict__.iteritems()]
15282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15283 
 
15284 
  def __eq__(self, other):
15285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15286 
 
15287 
  def __ne__(self, other):
15288 
    return not (self == other)
15289 
 
15290 
class getUriMapping_args:
15291 
  """
15292 
  Attributes:
15293 
   - bannerName
9155 kshitij.so 15294 
   - bannerType
8579 kshitij.so 15295 
  """
15296 
 
15297 
  thrift_spec = (
15298 
    None, # 0
15299 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 15300 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 15301 
  )
15302 
 
9155 kshitij.so 15303 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 15304 
    self.bannerName = bannerName
9155 kshitij.so 15305 
    self.bannerType = bannerType
8579 kshitij.so 15306 
 
15307 
  def read(self, iprot):
15308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15310 
      return
15311 
    iprot.readStructBegin()
15312 
    while True:
15313 
      (fname, ftype, fid) = iprot.readFieldBegin()
15314 
      if ftype == TType.STOP:
15315 
        break
15316 
      if fid == 1:
15317 
        if ftype == TType.STRING:
15318 
          self.bannerName = iprot.readString();
15319 
        else:
15320 
          iprot.skip(ftype)
9155 kshitij.so 15321 
      elif fid == 2:
15322 
        if ftype == TType.I32:
15323 
          self.bannerType = iprot.readI32();
15324 
        else:
15325 
          iprot.skip(ftype)
8579 kshitij.so 15326 
      else:
15327 
        iprot.skip(ftype)
15328 
      iprot.readFieldEnd()
15329 
    iprot.readStructEnd()
15330 
 
15331 
  def write(self, oprot):
15332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15334 
      return
15335 
    oprot.writeStructBegin('getUriMapping_args')
15336 
    if self.bannerName is not None:
15337 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
15338 
      oprot.writeString(self.bannerName)
15339 
      oprot.writeFieldEnd()
9155 kshitij.so 15340 
    if self.bannerType is not None:
15341 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
15342 
      oprot.writeI32(self.bannerType)
15343 
      oprot.writeFieldEnd()
8579 kshitij.so 15344 
    oprot.writeFieldStop()
15345 
    oprot.writeStructEnd()
15346 
 
15347 
  def validate(self):
15348 
    return
15349 
 
15350 
 
15351 
  def __repr__(self):
15352 
    L = ['%s=%r' % (key, value)
15353 
      for key, value in self.__dict__.iteritems()]
15354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15355 
 
15356 
  def __eq__(self, other):
15357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15358 
 
15359 
  def __ne__(self, other):
15360 
    return not (self == other)
15361 
 
15362 
class getUriMapping_result:
15363 
  """
15364 
  Attributes:
15365 
   - success
15366 
  """
15367 
 
15368 
  thrift_spec = (
15369 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
15370 
  )
15371 
 
15372 
  def __init__(self, success=None,):
15373 
    self.success = success
15374 
 
15375 
  def read(self, iprot):
15376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15378 
      return
15379 
    iprot.readStructBegin()
15380 
    while True:
15381 
      (fname, ftype, fid) = iprot.readFieldBegin()
15382 
      if ftype == TType.STOP:
15383 
        break
15384 
      if fid == 0:
15385 
        if ftype == TType.LIST:
15386 
          self.success = []
8590 kshitij.so 15387 
          (_etype242, _size239) = iprot.readListBegin()
15388 
          for _i243 in xrange(_size239):
15389 
            _elem244 = BannerUriMapping()
15390 
            _elem244.read(iprot)
15391 
            self.success.append(_elem244)
8579 kshitij.so 15392 
          iprot.readListEnd()
15393 
        else:
15394 
          iprot.skip(ftype)
15395 
      else:
15396 
        iprot.skip(ftype)
15397 
      iprot.readFieldEnd()
15398 
    iprot.readStructEnd()
15399 
 
15400 
  def write(self, oprot):
15401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15403 
      return
15404 
    oprot.writeStructBegin('getUriMapping_result')
15405 
    if self.success is not None:
15406 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15407 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15408 
      for iter245 in self.success:
15409 
        iter245.write(oprot)
8579 kshitij.so 15410 
      oprot.writeListEnd()
15411 
      oprot.writeFieldEnd()
15412 
    oprot.writeFieldStop()
15413 
    oprot.writeStructEnd()
15414 
 
15415 
  def validate(self):
15416 
    return
15417 
 
15418 
 
15419 
  def __repr__(self):
15420 
    L = ['%s=%r' % (key, value)
15421 
      for key, value in self.__dict__.iteritems()]
15422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15423 
 
15424 
  def __eq__(self, other):
15425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15426 
 
15427 
  def __ne__(self, other):
15428 
    return not (self == other)
15429 
 
15430 
class addCampaign_args:
15431 
  """
15432 
  Attributes:
15433 
   - campaign
15434 
  """
15435 
 
15436 
  thrift_spec = (
15437 
    None, # 0
15438 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
15439 
  )
15440 
 
15441 
  def __init__(self, campaign=None,):
15442 
    self.campaign = campaign
15443 
 
15444 
  def read(self, iprot):
15445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15447 
      return
15448 
    iprot.readStructBegin()
15449 
    while True:
15450 
      (fname, ftype, fid) = iprot.readFieldBegin()
15451 
      if ftype == TType.STOP:
15452 
        break
15453 
      if fid == 1:
15454 
        if ftype == TType.STRUCT:
15455 
          self.campaign = Campaign()
15456 
          self.campaign.read(iprot)
15457 
        else:
15458 
          iprot.skip(ftype)
15459 
      else:
15460 
        iprot.skip(ftype)
15461 
      iprot.readFieldEnd()
15462 
    iprot.readStructEnd()
15463 
 
15464 
  def write(self, oprot):
15465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15467 
      return
15468 
    oprot.writeStructBegin('addCampaign_args')
15469 
    if self.campaign is not None:
15470 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
15471 
      self.campaign.write(oprot)
15472 
      oprot.writeFieldEnd()
15473 
    oprot.writeFieldStop()
15474 
    oprot.writeStructEnd()
15475 
 
15476 
  def validate(self):
15477 
    return
15478 
 
15479 
 
15480 
  def __repr__(self):
15481 
    L = ['%s=%r' % (key, value)
15482 
      for key, value in self.__dict__.iteritems()]
15483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15484 
 
15485 
  def __eq__(self, other):
15486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15487 
 
15488 
  def __ne__(self, other):
15489 
    return not (self == other)
15490 
 
15491 
class addCampaign_result:
15492 
 
15493 
  thrift_spec = (
15494 
  )
15495 
 
15496 
  def read(self, iprot):
15497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15499 
      return
15500 
    iprot.readStructBegin()
15501 
    while True:
15502 
      (fname, ftype, fid) = iprot.readFieldBegin()
15503 
      if ftype == TType.STOP:
15504 
        break
15505 
      else:
15506 
        iprot.skip(ftype)
15507 
      iprot.readFieldEnd()
15508 
    iprot.readStructEnd()
15509 
 
15510 
  def write(self, oprot):
15511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15513 
      return
15514 
    oprot.writeStructBegin('addCampaign_result')
15515 
    oprot.writeFieldStop()
15516 
    oprot.writeStructEnd()
15517 
 
15518 
  def validate(self):
15519 
    return
15520 
 
15521 
 
15522 
  def __repr__(self):
15523 
    L = ['%s=%r' % (key, value)
15524 
      for key, value in self.__dict__.iteritems()]
15525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15526 
 
15527 
  def __eq__(self, other):
15528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15529 
 
15530 
  def __ne__(self, other):
15531 
    return not (self == other)
15532 
 
15533 
class getCampaigns_args:
15534 
  """
15535 
  Attributes:
15536 
   - campaignName
15537 
  """
15538 
 
15539 
  thrift_spec = (
15540 
    None, # 0
15541 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
15542 
  )
15543 
 
15544 
  def __init__(self, campaignName=None,):
15545 
    self.campaignName = campaignName
15546 
 
15547 
  def read(self, iprot):
15548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15550 
      return
15551 
    iprot.readStructBegin()
15552 
    while True:
15553 
      (fname, ftype, fid) = iprot.readFieldBegin()
15554 
      if ftype == TType.STOP:
15555 
        break
15556 
      if fid == 1:
15557 
        if ftype == TType.STRING:
15558 
          self.campaignName = iprot.readString();
15559 
        else:
15560 
          iprot.skip(ftype)
15561 
      else:
15562 
        iprot.skip(ftype)
15563 
      iprot.readFieldEnd()
15564 
    iprot.readStructEnd()
15565 
 
15566 
  def write(self, oprot):
15567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15569 
      return
15570 
    oprot.writeStructBegin('getCampaigns_args')
15571 
    if self.campaignName is not None:
15572 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
15573 
      oprot.writeString(self.campaignName)
15574 
      oprot.writeFieldEnd()
15575 
    oprot.writeFieldStop()
15576 
    oprot.writeStructEnd()
15577 
 
15578 
  def validate(self):
15579 
    return
15580 
 
15581 
 
15582 
  def __repr__(self):
15583 
    L = ['%s=%r' % (key, value)
15584 
      for key, value in self.__dict__.iteritems()]
15585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15586 
 
15587 
  def __eq__(self, other):
15588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15589 
 
15590 
  def __ne__(self, other):
15591 
    return not (self == other)
15592 
 
15593 
class getCampaigns_result:
15594 
  """
15595 
  Attributes:
15596 
   - success
15597 
  """
15598 
 
15599 
  thrift_spec = (
15600 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
15601 
  )
15602 
 
15603 
  def __init__(self, success=None,):
15604 
    self.success = success
15605 
 
15606 
  def read(self, iprot):
15607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15609 
      return
15610 
    iprot.readStructBegin()
15611 
    while True:
15612 
      (fname, ftype, fid) = iprot.readFieldBegin()
15613 
      if ftype == TType.STOP:
15614 
        break
15615 
      if fid == 0:
15616 
        if ftype == TType.LIST:
15617 
          self.success = []
8590 kshitij.so 15618 
          (_etype249, _size246) = iprot.readListBegin()
15619 
          for _i250 in xrange(_size246):
15620 
            _elem251 = Campaign()
15621 
            _elem251.read(iprot)
15622 
            self.success.append(_elem251)
8579 kshitij.so 15623 
          iprot.readListEnd()
15624 
        else:
15625 
          iprot.skip(ftype)
15626 
      else:
15627 
        iprot.skip(ftype)
15628 
      iprot.readFieldEnd()
15629 
    iprot.readStructEnd()
15630 
 
15631 
  def write(self, oprot):
15632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15634 
      return
15635 
    oprot.writeStructBegin('getCampaigns_result')
15636 
    if self.success is not None:
15637 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15638 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15639 
      for iter252 in self.success:
15640 
        iter252.write(oprot)
8579 kshitij.so 15641 
      oprot.writeListEnd()
15642 
      oprot.writeFieldEnd()
15643 
    oprot.writeFieldStop()
15644 
    oprot.writeStructEnd()
15645 
 
15646 
  def validate(self):
15647 
    return
15648 
 
15649 
 
15650 
  def __repr__(self):
15651 
    L = ['%s=%r' % (key, value)
15652 
      for key, value in self.__dict__.iteritems()]
15653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15654 
 
15655 
  def __eq__(self, other):
15656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15657 
 
15658 
  def __ne__(self, other):
15659 
    return not (self == other)
15660 
 
15661 
class deleteCampaign_args:
15662 
  """
15663 
  Attributes:
15664 
   - campaignId
15665 
  """
15666 
 
15667 
  thrift_spec = (
15668 
    None, # 0
15669 
    (1, TType.I64, 'campaignId', None, None, ), # 1
15670 
  )
15671 
 
15672 
  def __init__(self, campaignId=None,):
15673 
    self.campaignId = campaignId
15674 
 
15675 
  def read(self, iprot):
15676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15678 
      return
15679 
    iprot.readStructBegin()
15680 
    while True:
15681 
      (fname, ftype, fid) = iprot.readFieldBegin()
15682 
      if ftype == TType.STOP:
15683 
        break
15684 
      if fid == 1:
15685 
        if ftype == TType.I64:
15686 
          self.campaignId = iprot.readI64();
15687 
        else:
15688 
          iprot.skip(ftype)
15689 
      else:
15690 
        iprot.skip(ftype)
15691 
      iprot.readFieldEnd()
15692 
    iprot.readStructEnd()
15693 
 
15694 
  def write(self, oprot):
15695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15697 
      return
15698 
    oprot.writeStructBegin('deleteCampaign_args')
15699 
    if self.campaignId is not None:
15700 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
15701 
      oprot.writeI64(self.campaignId)
15702 
      oprot.writeFieldEnd()
15703 
    oprot.writeFieldStop()
15704 
    oprot.writeStructEnd()
15705 
 
15706 
  def validate(self):
15707 
    return
15708 
 
15709 
 
15710 
  def __repr__(self):
15711 
    L = ['%s=%r' % (key, value)
15712 
      for key, value in self.__dict__.iteritems()]
15713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15714 
 
15715 
  def __eq__(self, other):
15716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15717 
 
15718 
  def __ne__(self, other):
15719 
    return not (self == other)
15720 
 
15721 
class deleteCampaign_result:
15722 
 
15723 
  thrift_spec = (
15724 
  )
15725 
 
15726 
  def read(self, iprot):
15727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15729 
      return
15730 
    iprot.readStructBegin()
15731 
    while True:
15732 
      (fname, ftype, fid) = iprot.readFieldBegin()
15733 
      if ftype == TType.STOP:
15734 
        break
15735 
      else:
15736 
        iprot.skip(ftype)
15737 
      iprot.readFieldEnd()
15738 
    iprot.readStructEnd()
15739 
 
15740 
  def write(self, oprot):
15741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15743 
      return
15744 
    oprot.writeStructBegin('deleteCampaign_result')
15745 
    oprot.writeFieldStop()
15746 
    oprot.writeStructEnd()
15747 
 
15748 
  def validate(self):
15749 
    return
15750 
 
15751 
 
15752 
  def __repr__(self):
15753 
    L = ['%s=%r' % (key, value)
15754 
      for key, value in self.__dict__.iteritems()]
15755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15756 
 
15757 
  def __eq__(self, other):
15758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15759 
 
15760 
  def __ne__(self, other):
15761 
    return not (self == other)
15762 
 
15763 
class getAllCampaigns_args:
15764 
 
15765 
  thrift_spec = (
15766 
  )
15767 
 
15768 
  def read(self, iprot):
15769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15771 
      return
15772 
    iprot.readStructBegin()
15773 
    while True:
15774 
      (fname, ftype, fid) = iprot.readFieldBegin()
15775 
      if ftype == TType.STOP:
15776 
        break
15777 
      else:
15778 
        iprot.skip(ftype)
15779 
      iprot.readFieldEnd()
15780 
    iprot.readStructEnd()
15781 
 
15782 
  def write(self, oprot):
15783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15785 
      return
15786 
    oprot.writeStructBegin('getAllCampaigns_args')
15787 
    oprot.writeFieldStop()
15788 
    oprot.writeStructEnd()
15789 
 
15790 
  def validate(self):
15791 
    return
15792 
 
15793 
 
15794 
  def __repr__(self):
15795 
    L = ['%s=%r' % (key, value)
15796 
      for key, value in self.__dict__.iteritems()]
15797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15798 
 
15799 
  def __eq__(self, other):
15800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15801 
 
15802 
  def __ne__(self, other):
15803 
    return not (self == other)
15804 
 
15805 
class getAllCampaigns_result:
15806 
  """
15807 
  Attributes:
15808 
   - success
15809 
  """
15810 
 
15811 
  thrift_spec = (
15812 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15813 
  )
15814 
 
15815 
  def __init__(self, success=None,):
15816 
    self.success = success
15817 
 
15818 
  def read(self, iprot):
15819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15821 
      return
15822 
    iprot.readStructBegin()
15823 
    while True:
15824 
      (fname, ftype, fid) = iprot.readFieldBegin()
15825 
      if ftype == TType.STOP:
15826 
        break
15827 
      if fid == 0:
15828 
        if ftype == TType.LIST:
15829 
          self.success = []
8590 kshitij.so 15830 
          (_etype256, _size253) = iprot.readListBegin()
15831 
          for _i257 in xrange(_size253):
15832 
            _elem258 = iprot.readString();
15833 
            self.success.append(_elem258)
8579 kshitij.so 15834 
          iprot.readListEnd()
15835 
        else:
15836 
          iprot.skip(ftype)
15837 
      else:
15838 
        iprot.skip(ftype)
15839 
      iprot.readFieldEnd()
15840 
    iprot.readStructEnd()
15841 
 
15842 
  def write(self, oprot):
15843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15845 
      return
15846 
    oprot.writeStructBegin('getAllCampaigns_result')
15847 
    if self.success is not None:
15848 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15849 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 15850 
      for iter259 in self.success:
15851 
        oprot.writeString(iter259)
8579 kshitij.so 15852 
      oprot.writeListEnd()
15853 
      oprot.writeFieldEnd()
15854 
    oprot.writeFieldStop()
15855 
    oprot.writeStructEnd()
15856 
 
15857 
  def validate(self):
15858 
    return
15859 
 
15860 
 
15861 
  def __repr__(self):
15862 
    L = ['%s=%r' % (key, value)
15863 
      for key, value in self.__dict__.iteritems()]
15864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15865 
 
15866 
  def __eq__(self, other):
15867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15868 
 
15869 
  def __ne__(self, other):
15870 
    return not (self == other)
15871 
 
9155 kshitij.so 15872 
class getActiveBannersForMobileSite_args:
15873 
 
15874 
  thrift_spec = (
15875 
  )
15876 
 
15877 
  def read(self, iprot):
15878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15880 
      return
15881 
    iprot.readStructBegin()
15882 
    while True:
15883 
      (fname, ftype, fid) = iprot.readFieldBegin()
15884 
      if ftype == TType.STOP:
15885 
        break
15886 
      else:
15887 
        iprot.skip(ftype)
15888 
      iprot.readFieldEnd()
15889 
    iprot.readStructEnd()
15890 
 
15891 
  def write(self, oprot):
15892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15894 
      return
15895 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
15896 
    oprot.writeFieldStop()
15897 
    oprot.writeStructEnd()
15898 
 
15899 
  def validate(self):
15900 
    return
15901 
 
15902 
 
15903 
  def __repr__(self):
15904 
    L = ['%s=%r' % (key, value)
15905 
      for key, value in self.__dict__.iteritems()]
15906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15907 
 
15908 
  def __eq__(self, other):
15909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15910 
 
15911 
  def __ne__(self, other):
15912 
    return not (self == other)
15913 
 
15914 
class getActiveBannersForMobileSite_result:
15915 
  """
15916 
  Attributes:
15917 
   - success
15918 
  """
15919 
 
15920 
  thrift_spec = (
15921 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
15922 
  )
15923 
 
15924 
  def __init__(self, success=None,):
15925 
    self.success = success
15926 
 
15927 
  def read(self, iprot):
15928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15930 
      return
15931 
    iprot.readStructBegin()
15932 
    while True:
15933 
      (fname, ftype, fid) = iprot.readFieldBegin()
15934 
      if ftype == TType.STOP:
15935 
        break
15936 
      if fid == 0:
15937 
        if ftype == TType.MAP:
15938 
          self.success = {}
15939 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
15940 
          for _i264 in xrange(_size260):
15941 
            _key265 = iprot.readString();
15942 
            _val266 = []
15943 
            (_etype270, _size267) = iprot.readListBegin()
15944 
            for _i271 in xrange(_size267):
15945 
              _elem272 = Banner()
15946 
              _elem272.read(iprot)
15947 
              _val266.append(_elem272)
15948 
            iprot.readListEnd()
15949 
            self.success[_key265] = _val266
15950 
          iprot.readMapEnd()
15951 
        else:
15952 
          iprot.skip(ftype)
15953 
      else:
15954 
        iprot.skip(ftype)
15955 
      iprot.readFieldEnd()
15956 
    iprot.readStructEnd()
15957 
 
15958 
  def write(self, oprot):
15959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15961 
      return
15962 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
15963 
    if self.success is not None:
15964 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15965 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
15966 
      for kiter273,viter274 in self.success.items():
15967 
        oprot.writeString(kiter273)
15968 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
15969 
        for iter275 in viter274:
15970 
          iter275.write(oprot)
15971 
        oprot.writeListEnd()
15972 
      oprot.writeMapEnd()
15973 
      oprot.writeFieldEnd()
15974 
    oprot.writeFieldStop()
15975 
    oprot.writeStructEnd()
15976 
 
15977 
  def validate(self):
15978 
    return
15979 
 
15980 
 
15981 
  def __repr__(self):
15982 
    L = ['%s=%r' % (key, value)
15983 
      for key, value in self.__dict__.iteritems()]
15984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15985 
 
15986 
  def __eq__(self, other):
15987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15988 
 
15989 
  def __ne__(self, other):
15990 
    return not (self == other)
15991 
 
5944 mandeep.dh 15992 
class deleteSimilarItem_args:
15993 
  """
15994 
  Attributes:
15995 
   - itemId
15996 
   - catalogItemId
15997 
  """
15998 
 
15999 
  thrift_spec = (
16000 
    None, # 0
16001 
    (1, TType.I64, 'itemId', None, None, ), # 1
16002 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
16003 
  )
16004 
 
16005 
  def __init__(self, itemId=None, catalogItemId=None,):
16006 
    self.itemId = itemId
16007 
    self.catalogItemId = catalogItemId
16008 
 
16009 
  def read(self, iprot):
16010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16012 
      return
16013 
    iprot.readStructBegin()
16014 
    while True:
16015 
      (fname, ftype, fid) = iprot.readFieldBegin()
16016 
      if ftype == TType.STOP:
16017 
        break
16018 
      if fid == 1:
16019 
        if ftype == TType.I64:
16020 
          self.itemId = iprot.readI64();
16021 
        else:
16022 
          iprot.skip(ftype)
16023 
      elif fid == 2:
16024 
        if ftype == TType.I64:
16025 
          self.catalogItemId = iprot.readI64();
16026 
        else:
16027 
          iprot.skip(ftype)
16028 
      else:
16029 
        iprot.skip(ftype)
16030 
      iprot.readFieldEnd()
16031 
    iprot.readStructEnd()
16032 
 
16033 
  def write(self, oprot):
16034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16036 
      return
16037 
    oprot.writeStructBegin('deleteSimilarItem_args')
16038 
    if self.itemId is not None:
16039 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16040 
      oprot.writeI64(self.itemId)
16041 
      oprot.writeFieldEnd()
16042 
    if self.catalogItemId is not None:
16043 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
16044 
      oprot.writeI64(self.catalogItemId)
16045 
      oprot.writeFieldEnd()
16046 
    oprot.writeFieldStop()
16047 
    oprot.writeStructEnd()
16048 
 
16049 
  def validate(self):
16050 
    return
16051 
 
16052 
 
16053 
  def __repr__(self):
16054 
    L = ['%s=%r' % (key, value)
16055 
      for key, value in self.__dict__.iteritems()]
16056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16057 
 
16058 
  def __eq__(self, other):
16059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16060 
 
16061 
  def __ne__(self, other):
16062 
    return not (self == other)
16063 
 
16064 
class deleteSimilarItem_result:
16065 
  """
16066 
  Attributes:
16067 
   - success
16068 
   - cex
16069 
  """
16070 
 
16071 
  thrift_spec = (
16072 
    (0, TType.BOOL, 'success', None, None, ), # 0
16073 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16074 
  )
16075 
 
16076 
  def __init__(self, success=None, cex=None,):
16077 
    self.success = success
16078 
    self.cex = cex
16079 
 
16080 
  def read(self, iprot):
16081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16083 
      return
16084 
    iprot.readStructBegin()
16085 
    while True:
16086 
      (fname, ftype, fid) = iprot.readFieldBegin()
16087 
      if ftype == TType.STOP:
16088 
        break
16089 
      if fid == 0:
16090 
        if ftype == TType.BOOL:
16091 
          self.success = iprot.readBool();
16092 
        else:
16093 
          iprot.skip(ftype)
16094 
      elif fid == 1:
16095 
        if ftype == TType.STRUCT:
16096 
          self.cex = CatalogServiceException()
16097 
          self.cex.read(iprot)
16098 
        else:
16099 
          iprot.skip(ftype)
16100 
      else:
16101 
        iprot.skip(ftype)
16102 
      iprot.readFieldEnd()
16103 
    iprot.readStructEnd()
16104 
 
16105 
  def write(self, oprot):
16106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16108 
      return
16109 
    oprot.writeStructBegin('deleteSimilarItem_result')
16110 
    if self.success is not None:
16111 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16112 
      oprot.writeBool(self.success)
16113 
      oprot.writeFieldEnd()
16114 
    if self.cex is not None:
16115 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16116 
      self.cex.write(oprot)
16117 
      oprot.writeFieldEnd()
16118 
    oprot.writeFieldStop()
16119 
    oprot.writeStructEnd()
16120 
 
16121 
  def validate(self):
16122 
    return
16123 
 
16124 
 
16125 
  def __repr__(self):
16126 
    L = ['%s=%r' % (key, value)
16127 
      for key, value in self.__dict__.iteritems()]
16128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16129 
 
16130 
  def __eq__(self, other):
16131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16132 
 
16133 
  def __ne__(self, other):
16134 
    return not (self == other)
16135 
 
16136 
class checkSimilarItem_args:
16137 
  """
16138 
  Attributes:
16139 
   - brand
16140 
   - modelNumber
16141 
   - modelName
16142 
   - color
16143 
  """
16144 
 
16145 
  thrift_spec = (
16146 
    None, # 0
16147 
    (1, TType.STRING, 'brand', None, None, ), # 1
16148 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
16149 
    (3, TType.STRING, 'modelName', None, None, ), # 3
16150 
    (4, TType.STRING, 'color', None, None, ), # 4
16151 
  )
16152 
 
16153 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
16154 
    self.brand = brand
16155 
    self.modelNumber = modelNumber
16156 
    self.modelName = modelName
16157 
    self.color = color
16158 
 
16159 
  def read(self, iprot):
16160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16162 
      return
16163 
    iprot.readStructBegin()
16164 
    while True:
16165 
      (fname, ftype, fid) = iprot.readFieldBegin()
16166 
      if ftype == TType.STOP:
16167 
        break
16168 
      if fid == 1:
16169 
        if ftype == TType.STRING:
16170 
          self.brand = iprot.readString();
16171 
        else:
16172 
          iprot.skip(ftype)
16173 
      elif fid == 2:
16174 
        if ftype == TType.STRING:
16175 
          self.modelNumber = iprot.readString();
16176 
        else:
16177 
          iprot.skip(ftype)
16178 
      elif fid == 3:
16179 
        if ftype == TType.STRING:
16180 
          self.modelName = iprot.readString();
16181 
        else:
16182 
          iprot.skip(ftype)
16183 
      elif fid == 4:
16184 
        if ftype == TType.STRING:
16185 
          self.color = iprot.readString();
16186 
        else:
16187 
          iprot.skip(ftype)
16188 
      else:
16189 
        iprot.skip(ftype)
16190 
      iprot.readFieldEnd()
16191 
    iprot.readStructEnd()
16192 
 
16193 
  def write(self, oprot):
16194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16196 
      return
16197 
    oprot.writeStructBegin('checkSimilarItem_args')
16198 
    if self.brand is not None:
16199 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
16200 
      oprot.writeString(self.brand)
16201 
      oprot.writeFieldEnd()
16202 
    if self.modelNumber is not None:
16203 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
16204 
      oprot.writeString(self.modelNumber)
16205 
      oprot.writeFieldEnd()
16206 
    if self.modelName is not None:
16207 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
16208 
      oprot.writeString(self.modelName)
16209 
      oprot.writeFieldEnd()
16210 
    if self.color is not None:
16211 
      oprot.writeFieldBegin('color', TType.STRING, 4)
16212 
      oprot.writeString(self.color)
16213 
      oprot.writeFieldEnd()
16214 
    oprot.writeFieldStop()
16215 
    oprot.writeStructEnd()
16216 
 
16217 
  def validate(self):
16218 
    return
16219 
 
16220 
 
16221 
  def __repr__(self):
16222 
    L = ['%s=%r' % (key, value)
16223 
      for key, value in self.__dict__.iteritems()]
16224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16225 
 
16226 
  def __eq__(self, other):
16227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16228 
 
16229 
  def __ne__(self, other):
16230 
    return not (self == other)
16231 
 
16232 
class checkSimilarItem_result:
16233 
  """
16234 
  Attributes:
16235 
   - success
16236 
  """
16237 
 
16238 
  thrift_spec = (
16239 
    (0, TType.I64, 'success', None, None, ), # 0
16240 
  )
16241 
 
16242 
  def __init__(self, success=None,):
16243 
    self.success = success
16244 
 
16245 
  def read(self, iprot):
16246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16248 
      return
16249 
    iprot.readStructBegin()
16250 
    while True:
16251 
      (fname, ftype, fid) = iprot.readFieldBegin()
16252 
      if ftype == TType.STOP:
16253 
        break
16254 
      if fid == 0:
16255 
        if ftype == TType.I64:
16256 
          self.success = iprot.readI64();
16257 
        else:
16258 
          iprot.skip(ftype)
16259 
      else:
16260 
        iprot.skip(ftype)
16261 
      iprot.readFieldEnd()
16262 
    iprot.readStructEnd()
16263 
 
16264 
  def write(self, oprot):
16265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16267 
      return
16268 
    oprot.writeStructBegin('checkSimilarItem_result')
16269 
    if self.success is not None:
16270 
      oprot.writeFieldBegin('success', TType.I64, 0)
16271 
      oprot.writeI64(self.success)
16272 
      oprot.writeFieldEnd()
16273 
    oprot.writeFieldStop()
16274 
    oprot.writeStructEnd()
16275 
 
16276 
  def validate(self):
16277 
    return
16278 
 
16279 
 
16280 
  def __repr__(self):
16281 
    L = ['%s=%r' % (key, value)
16282 
      for key, value in self.__dict__.iteritems()]
16283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16284 
 
16285 
  def __eq__(self, other):
16286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16287 
 
16288 
  def __ne__(self, other):
16289 
    return not (self == other)
16290 
 
16291 
class validateRiskyStatus_args:
16292 
  """
16293 
  Attributes:
16294 
   - itemId
16295 
  """
16296 
 
16297 
  thrift_spec = (
16298 
    None, # 0
16299 
    (1, TType.I64, 'itemId', None, None, ), # 1
16300 
  )
16301 
 
16302 
  def __init__(self, itemId=None,):
16303 
    self.itemId = itemId
16304 
 
16305 
  def read(self, iprot):
16306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16308 
      return
16309 
    iprot.readStructBegin()
16310 
    while True:
16311 
      (fname, ftype, fid) = iprot.readFieldBegin()
16312 
      if ftype == TType.STOP:
16313 
        break
16314 
      if fid == 1:
16315 
        if ftype == TType.I64:
16316 
          self.itemId = iprot.readI64();
16317 
        else:
16318 
          iprot.skip(ftype)
16319 
      else:
16320 
        iprot.skip(ftype)
16321 
      iprot.readFieldEnd()
16322 
    iprot.readStructEnd()
16323 
 
16324 
  def write(self, oprot):
16325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16327 
      return
16328 
    oprot.writeStructBegin('validateRiskyStatus_args')
16329 
    if self.itemId is not None:
16330 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16331 
      oprot.writeI64(self.itemId)
16332 
      oprot.writeFieldEnd()
16333 
    oprot.writeFieldStop()
16334 
    oprot.writeStructEnd()
16335 
 
16336 
  def validate(self):
16337 
    return
16338 
 
16339 
 
16340 
  def __repr__(self):
16341 
    L = ['%s=%r' % (key, value)
16342 
      for key, value in self.__dict__.iteritems()]
16343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16344 
 
16345 
  def __eq__(self, other):
16346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16347 
 
16348 
  def __ne__(self, other):
16349 
    return not (self == other)
16350 
 
16351 
class validateRiskyStatus_result:
16352 
 
16353 
  thrift_spec = (
16354 
  )
16355 
 
16356 
  def read(self, iprot):
16357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16359 
      return
16360 
    iprot.readStructBegin()
16361 
    while True:
16362 
      (fname, ftype, fid) = iprot.readFieldBegin()
16363 
      if ftype == TType.STOP:
16364 
        break
16365 
      else:
16366 
        iprot.skip(ftype)
16367 
      iprot.readFieldEnd()
16368 
    iprot.readStructEnd()
16369 
 
16370 
  def write(self, oprot):
16371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16373 
      return
16374 
    oprot.writeStructBegin('validateRiskyStatus_result')
16375 
    oprot.writeFieldStop()
16376 
    oprot.writeStructEnd()
16377 
 
16378 
  def validate(self):
16379 
    return
16380 
 
16381 
 
16382 
  def __repr__(self):
16383 
    L = ['%s=%r' % (key, value)
16384 
      for key, value in self.__dict__.iteritems()]
16385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16386 
 
16387 
  def __eq__(self, other):
16388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16389 
 
16390 
  def __ne__(self, other):
16391 
    return not (self == other)
16392 
 
16393 
class changeItemRiskyFlag_args:
16394 
  """
16395 
  Attributes:
16396 
   - itemId
16397 
   - risky
16398 
  """
16399 
 
16400 
  thrift_spec = (
16401 
    None, # 0
16402 
    (1, TType.I64, 'itemId', None, None, ), # 1
16403 
    (2, TType.BOOL, 'risky', None, None, ), # 2
16404 
  )
16405 
 
16406 
  def __init__(self, itemId=None, risky=None,):
16407 
    self.itemId = itemId
16408 
    self.risky = risky
16409 
 
16410 
  def read(self, iprot):
16411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16413 
      return
16414 
    iprot.readStructBegin()
16415 
    while True:
16416 
      (fname, ftype, fid) = iprot.readFieldBegin()
16417 
      if ftype == TType.STOP:
16418 
        break
16419 
      if fid == 1:
16420 
        if ftype == TType.I64:
16421 
          self.itemId = iprot.readI64();
16422 
        else:
16423 
          iprot.skip(ftype)
16424 
      elif fid == 2:
16425 
        if ftype == TType.BOOL:
16426 
          self.risky = iprot.readBool();
16427 
        else:
16428 
          iprot.skip(ftype)
16429 
      else:
16430 
        iprot.skip(ftype)
16431 
      iprot.readFieldEnd()
16432 
    iprot.readStructEnd()
16433 
 
16434 
  def write(self, oprot):
16435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16437 
      return
16438 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
16439 
    if self.itemId is not None:
16440 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16441 
      oprot.writeI64(self.itemId)
16442 
      oprot.writeFieldEnd()
16443 
    if self.risky is not None:
16444 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
16445 
      oprot.writeBool(self.risky)
16446 
      oprot.writeFieldEnd()
16447 
    oprot.writeFieldStop()
16448 
    oprot.writeStructEnd()
16449 
 
16450 
  def validate(self):
16451 
    return
16452 
 
16453 
 
16454 
  def __repr__(self):
16455 
    L = ['%s=%r' % (key, value)
16456 
      for key, value in self.__dict__.iteritems()]
16457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16458 
 
16459 
  def __eq__(self, other):
16460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16461 
 
16462 
  def __ne__(self, other):
16463 
    return not (self == other)
16464 
 
16465 
class changeItemRiskyFlag_result:
16466 
 
16467 
  thrift_spec = (
16468 
  )
16469 
 
16470 
  def read(self, iprot):
16471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16473 
      return
16474 
    iprot.readStructBegin()
16475 
    while True:
16476 
      (fname, ftype, fid) = iprot.readFieldBegin()
16477 
      if ftype == TType.STOP:
16478 
        break
16479 
      else:
16480 
        iprot.skip(ftype)
16481 
      iprot.readFieldEnd()
16482 
    iprot.readStructEnd()
16483 
 
16484 
  def write(self, oprot):
16485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16487 
      return
16488 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
16489 
    oprot.writeFieldStop()
16490 
    oprot.writeStructEnd()
16491 
 
16492 
  def validate(self):
16493 
    return
16494 
 
16495 
 
16496 
  def __repr__(self):
16497 
    L = ['%s=%r' % (key, value)
16498 
      for key, value in self.__dict__.iteritems()]
16499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16500 
 
16501 
  def __eq__(self, other):
16502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16503 
 
16504 
  def __ne__(self, other):
16505 
    return not (self == other)
16506 
 
16507 
class getItemsByRiskyFlag_args:
16508 
 
16509 
  thrift_spec = (
16510 
  )
16511 
 
16512 
  def read(self, iprot):
16513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16515 
      return
16516 
    iprot.readStructBegin()
16517 
    while True:
16518 
      (fname, ftype, fid) = iprot.readFieldBegin()
16519 
      if ftype == TType.STOP:
16520 
        break
16521 
      else:
16522 
        iprot.skip(ftype)
16523 
      iprot.readFieldEnd()
16524 
    iprot.readStructEnd()
16525 
 
16526 
  def write(self, oprot):
16527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16529 
      return
16530 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
16531 
    oprot.writeFieldStop()
16532 
    oprot.writeStructEnd()
16533 
 
16534 
  def validate(self):
16535 
    return
16536 
 
16537 
 
16538 
  def __repr__(self):
16539 
    L = ['%s=%r' % (key, value)
16540 
      for key, value in self.__dict__.iteritems()]
16541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16542 
 
16543 
  def __eq__(self, other):
16544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16545 
 
16546 
  def __ne__(self, other):
16547 
    return not (self == other)
16548 
 
16549 
class getItemsByRiskyFlag_result:
16550 
  """
16551 
  Attributes:
16552 
   - success
16553 
  """
16554 
 
16555 
  thrift_spec = (
16556 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16557 
  )
16558 
 
16559 
  def __init__(self, success=None,):
16560 
    self.success = success
16561 
 
16562 
  def read(self, iprot):
16563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16565 
      return
16566 
    iprot.readStructBegin()
16567 
    while True:
16568 
      (fname, ftype, fid) = iprot.readFieldBegin()
16569 
      if ftype == TType.STOP:
16570 
        break
16571 
      if fid == 0:
16572 
        if ftype == TType.LIST:
16573 
          self.success = []
9155 kshitij.so 16574 
          (_etype279, _size276) = iprot.readListBegin()
16575 
          for _i280 in xrange(_size276):
16576 
            _elem281 = Item()
16577 
            _elem281.read(iprot)
16578 
            self.success.append(_elem281)
5944 mandeep.dh 16579 
          iprot.readListEnd()
16580 
        else:
16581 
          iprot.skip(ftype)
16582 
      else:
16583 
        iprot.skip(ftype)
16584 
      iprot.readFieldEnd()
16585 
    iprot.readStructEnd()
16586 
 
16587 
  def write(self, oprot):
16588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16590 
      return
16591 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
16592 
    if self.success is not None:
16593 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16594 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16595 
      for iter282 in self.success:
16596 
        iter282.write(oprot)
5944 mandeep.dh 16597 
      oprot.writeListEnd()
16598 
      oprot.writeFieldEnd()
16599 
    oprot.writeFieldStop()
16600 
    oprot.writeStructEnd()
16601 
 
16602 
  def validate(self):
16603 
    return
16604 
 
16605 
 
16606 
  def __repr__(self):
16607 
    L = ['%s=%r' % (key, value)
16608 
      for key, value in self.__dict__.iteritems()]
16609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16610 
 
16611 
  def __eq__(self, other):
16612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16613 
 
16614 
  def __ne__(self, other):
16615 
    return not (self == other)
16616 
 
16617 
class getItemsForMasterSheet_args:
16618 
  """
16619 
  Attributes:
16620 
   - category
16621 
   - brand
16622 
  """
16623 
 
16624 
  thrift_spec = (
16625 
    None, # 0
16626 
    (1, TType.STRING, 'category', None, None, ), # 1
16627 
    (2, TType.STRING, 'brand', None, None, ), # 2
16628 
  )
16629 
 
16630 
  def __init__(self, category=None, brand=None,):
16631 
    self.category = category
16632 
    self.brand = brand
16633 
 
16634 
  def read(self, iprot):
16635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16637 
      return
16638 
    iprot.readStructBegin()
16639 
    while True:
16640 
      (fname, ftype, fid) = iprot.readFieldBegin()
16641 
      if ftype == TType.STOP:
16642 
        break
16643 
      if fid == 1:
16644 
        if ftype == TType.STRING:
16645 
          self.category = iprot.readString();
16646 
        else:
16647 
          iprot.skip(ftype)
16648 
      elif fid == 2:
16649 
        if ftype == TType.STRING:
16650 
          self.brand = iprot.readString();
16651 
        else:
16652 
          iprot.skip(ftype)
16653 
      else:
16654 
        iprot.skip(ftype)
16655 
      iprot.readFieldEnd()
16656 
    iprot.readStructEnd()
16657 
 
16658 
  def write(self, oprot):
16659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16661 
      return
16662 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
16663 
    if self.category is not None:
16664 
      oprot.writeFieldBegin('category', TType.STRING, 1)
16665 
      oprot.writeString(self.category)
16666 
      oprot.writeFieldEnd()
16667 
    if self.brand is not None:
16668 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
16669 
      oprot.writeString(self.brand)
16670 
      oprot.writeFieldEnd()
16671 
    oprot.writeFieldStop()
16672 
    oprot.writeStructEnd()
16673 
 
16674 
  def validate(self):
16675 
    return
16676 
 
16677 
 
16678 
  def __repr__(self):
16679 
    L = ['%s=%r' % (key, value)
16680 
      for key, value in self.__dict__.iteritems()]
16681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16682 
 
16683 
  def __eq__(self, other):
16684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16685 
 
16686 
  def __ne__(self, other):
16687 
    return not (self == other)
16688 
 
16689 
class getItemsForMasterSheet_result:
16690 
  """
16691 
  Attributes:
16692 
   - success
16693 
  """
16694 
 
16695 
  thrift_spec = (
16696 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16697 
  )
16698 
 
16699 
  def __init__(self, success=None,):
16700 
    self.success = success
16701 
 
16702 
  def read(self, iprot):
16703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16705 
      return
16706 
    iprot.readStructBegin()
16707 
    while True:
16708 
      (fname, ftype, fid) = iprot.readFieldBegin()
16709 
      if ftype == TType.STOP:
16710 
        break
16711 
      if fid == 0:
16712 
        if ftype == TType.LIST:
16713 
          self.success = []
9155 kshitij.so 16714 
          (_etype286, _size283) = iprot.readListBegin()
16715 
          for _i287 in xrange(_size283):
16716 
            _elem288 = Item()
16717 
            _elem288.read(iprot)
16718 
            self.success.append(_elem288)
5944 mandeep.dh 16719 
          iprot.readListEnd()
16720 
        else:
16721 
          iprot.skip(ftype)
16722 
      else:
16723 
        iprot.skip(ftype)
16724 
      iprot.readFieldEnd()
16725 
    iprot.readStructEnd()
16726 
 
16727 
  def write(self, oprot):
16728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16730 
      return
16731 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
16732 
    if self.success is not None:
16733 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16734 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16735 
      for iter289 in self.success:
16736 
        iter289.write(oprot)
5944 mandeep.dh 16737 
      oprot.writeListEnd()
16738 
      oprot.writeFieldEnd()
16739 
    oprot.writeFieldStop()
16740 
    oprot.writeStructEnd()
16741 
 
16742 
  def validate(self):
16743 
    return
16744 
 
16745 
 
16746 
  def __repr__(self):
16747 
    L = ['%s=%r' % (key, value)
16748 
      for key, value in self.__dict__.iteritems()]
16749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16750 
 
16751 
  def __eq__(self, other):
16752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16753 
 
16754 
  def __ne__(self, other):
16755 
    return not (self == other)
16756 
 
16757 
class getSimilarItemsCatalogIds_args:
16758 
  """
16759 
  Attributes:
16760 
   - beginIndex
16761 
   - totalItems
16762 
   - itemId
16763 
  """
16764 
 
16765 
  thrift_spec = (
16766 
    None, # 0
16767 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
16768 
    (2, TType.I64, 'totalItems', None, None, ), # 2
16769 
    (3, TType.I64, 'itemId', None, None, ), # 3
16770 
  )
16771 
 
16772 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
16773 
    self.beginIndex = beginIndex
16774 
    self.totalItems = totalItems
16775 
    self.itemId = itemId
16776 
 
16777 
  def read(self, iprot):
16778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16780 
      return
16781 
    iprot.readStructBegin()
16782 
    while True:
16783 
      (fname, ftype, fid) = iprot.readFieldBegin()
16784 
      if ftype == TType.STOP:
16785 
        break
16786 
      if fid == 1:
16787 
        if ftype == TType.I64:
16788 
          self.beginIndex = iprot.readI64();
16789 
        else:
16790 
          iprot.skip(ftype)
16791 
      elif fid == 2:
16792 
        if ftype == TType.I64:
16793 
          self.totalItems = iprot.readI64();
16794 
        else:
16795 
          iprot.skip(ftype)
16796 
      elif fid == 3:
16797 
        if ftype == TType.I64:
16798 
          self.itemId = iprot.readI64();
16799 
        else:
16800 
          iprot.skip(ftype)
16801 
      else:
16802 
        iprot.skip(ftype)
16803 
      iprot.readFieldEnd()
16804 
    iprot.readStructEnd()
16805 
 
16806 
  def write(self, oprot):
16807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16809 
      return
16810 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
16811 
    if self.beginIndex is not None:
16812 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
16813 
      oprot.writeI64(self.beginIndex)
16814 
      oprot.writeFieldEnd()
16815 
    if self.totalItems is not None:
16816 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
16817 
      oprot.writeI64(self.totalItems)
16818 
      oprot.writeFieldEnd()
16819 
    if self.itemId is not None:
16820 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
16821 
      oprot.writeI64(self.itemId)
16822 
      oprot.writeFieldEnd()
16823 
    oprot.writeFieldStop()
16824 
    oprot.writeStructEnd()
16825 
 
16826 
  def validate(self):
16827 
    return
16828 
 
16829 
 
16830 
  def __repr__(self):
16831 
    L = ['%s=%r' % (key, value)
16832 
      for key, value in self.__dict__.iteritems()]
16833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16834 
 
16835 
  def __eq__(self, other):
16836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16837 
 
16838 
  def __ne__(self, other):
16839 
    return not (self == other)
16840 
 
16841 
class getSimilarItemsCatalogIds_result:
16842 
  """
16843 
  Attributes:
16844 
   - success
16845 
  """
16846 
 
16847 
  thrift_spec = (
16848 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
16849 
  )
16850 
 
16851 
  def __init__(self, success=None,):
16852 
    self.success = success
16853 
 
16854 
  def read(self, iprot):
16855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16857 
      return
16858 
    iprot.readStructBegin()
16859 
    while True:
16860 
      (fname, ftype, fid) = iprot.readFieldBegin()
16861 
      if ftype == TType.STOP:
16862 
        break
16863 
      if fid == 0:
16864 
        if ftype == TType.LIST:
16865 
          self.success = []
9155 kshitij.so 16866 
          (_etype293, _size290) = iprot.readListBegin()
16867 
          for _i294 in xrange(_size290):
16868 
            _elem295 = iprot.readI64();
16869 
            self.success.append(_elem295)
5944 mandeep.dh 16870 
          iprot.readListEnd()
16871 
        else:
16872 
          iprot.skip(ftype)
16873 
      else:
16874 
        iprot.skip(ftype)
16875 
      iprot.readFieldEnd()
16876 
    iprot.readStructEnd()
16877 
 
16878 
  def write(self, oprot):
16879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16881 
      return
16882 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
16883 
    if self.success is not None:
16884 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16885 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 16886 
      for iter296 in self.success:
16887 
        oprot.writeI64(iter296)
5944 mandeep.dh 16888 
      oprot.writeListEnd()
16889 
      oprot.writeFieldEnd()
16890 
    oprot.writeFieldStop()
16891 
    oprot.writeStructEnd()
16892 
 
16893 
  def validate(self):
16894 
    return
16895 
 
16896 
 
16897 
  def __repr__(self):
16898 
    L = ['%s=%r' % (key, value)
16899 
      for key, value in self.__dict__.iteritems()]
16900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16901 
 
16902 
  def __eq__(self, other):
16903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16904 
 
16905 
  def __ne__(self, other):
16906 
    return not (self == other)
16907 
 
16908 
class addProductNotification_args:
16909 
  """
16910 
  Attributes:
16911 
   - itemId
16912 
   - email
16913 
  """
16914 
 
16915 
  thrift_spec = None
16916 
  def __init__(self, itemId=None, email=None,):
16917 
    self.itemId = itemId
16918 
    self.email = email
16919 
 
16920 
  def read(self, iprot):
16921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16923 
      return
16924 
    iprot.readStructBegin()
16925 
    while True:
16926 
      (fname, ftype, fid) = iprot.readFieldBegin()
16927 
      if ftype == TType.STOP:
16928 
        break
16929 
      if fid == -1:
16930 
        if ftype == TType.I64:
16931 
          self.itemId = iprot.readI64();
16932 
        else:
16933 
          iprot.skip(ftype)
16934 
      elif fid == -2:
16935 
        if ftype == TType.STRING:
16936 
          self.email = iprot.readString();
16937 
        else:
16938 
          iprot.skip(ftype)
16939 
      else:
16940 
        iprot.skip(ftype)
16941 
      iprot.readFieldEnd()
16942 
    iprot.readStructEnd()
16943 
 
16944 
  def write(self, oprot):
16945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16947 
      return
16948 
    oprot.writeStructBegin('addProductNotification_args')
16949 
    if self.email is not None:
16950 
      oprot.writeFieldBegin('email', TType.STRING, -2)
16951 
      oprot.writeString(self.email)
16952 
      oprot.writeFieldEnd()
16953 
    if self.itemId is not None:
16954 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
16955 
      oprot.writeI64(self.itemId)
16956 
      oprot.writeFieldEnd()
16957 
    oprot.writeFieldStop()
16958 
    oprot.writeStructEnd()
16959 
 
16960 
  def validate(self):
16961 
    return
16962 
 
16963 
 
16964 
  def __repr__(self):
16965 
    L = ['%s=%r' % (key, value)
16966 
      for key, value in self.__dict__.iteritems()]
16967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16968 
 
16969 
  def __eq__(self, other):
16970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16971 
 
16972 
  def __ne__(self, other):
16973 
    return not (self == other)
16974 
 
16975 
class addProductNotification_result:
16976 
  """
16977 
  Attributes:
16978 
   - success
16979 
  """
16980 
 
16981 
  thrift_spec = (
16982 
    (0, TType.BOOL, 'success', None, None, ), # 0
16983 
  )
16984 
 
16985 
  def __init__(self, success=None,):
16986 
    self.success = success
16987 
 
16988 
  def read(self, iprot):
16989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16991 
      return
16992 
    iprot.readStructBegin()
16993 
    while True:
16994 
      (fname, ftype, fid) = iprot.readFieldBegin()
16995 
      if ftype == TType.STOP:
16996 
        break
16997 
      if fid == 0:
16998 
        if ftype == TType.BOOL:
16999 
          self.success = iprot.readBool();
17000 
        else:
17001 
          iprot.skip(ftype)
17002 
      else:
17003 
        iprot.skip(ftype)
17004 
      iprot.readFieldEnd()
17005 
    iprot.readStructEnd()
17006 
 
17007 
  def write(self, oprot):
17008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17010 
      return
17011 
    oprot.writeStructBegin('addProductNotification_result')
17012 
    if self.success is not None:
17013 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17014 
      oprot.writeBool(self.success)
17015 
      oprot.writeFieldEnd()
17016 
    oprot.writeFieldStop()
17017 
    oprot.writeStructEnd()
17018 
 
17019 
  def validate(self):
17020 
    return
17021 
 
17022 
 
17023 
  def __repr__(self):
17024 
    L = ['%s=%r' % (key, value)
17025 
      for key, value in self.__dict__.iteritems()]
17026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17027 
 
17028 
  def __eq__(self, other):
17029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17030 
 
17031 
  def __ne__(self, other):
17032 
    return not (self == other)
17033 
 
17034 
class sendProductNotifications_args:
17035 
 
17036 
  thrift_spec = (
17037 
  )
17038 
 
17039 
  def read(self, iprot):
17040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17042 
      return
17043 
    iprot.readStructBegin()
17044 
    while True:
17045 
      (fname, ftype, fid) = iprot.readFieldBegin()
17046 
      if ftype == TType.STOP:
17047 
        break
17048 
      else:
17049 
        iprot.skip(ftype)
17050 
      iprot.readFieldEnd()
17051 
    iprot.readStructEnd()
17052 
 
17053 
  def write(self, oprot):
17054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17056 
      return
17057 
    oprot.writeStructBegin('sendProductNotifications_args')
17058 
    oprot.writeFieldStop()
17059 
    oprot.writeStructEnd()
17060 
 
17061 
  def validate(self):
17062 
    return
17063 
 
17064 
 
17065 
  def __repr__(self):
17066 
    L = ['%s=%r' % (key, value)
17067 
      for key, value in self.__dict__.iteritems()]
17068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17069 
 
17070 
  def __eq__(self, other):
17071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17072 
 
17073 
  def __ne__(self, other):
17074 
    return not (self == other)
17075 
 
17076 
class sendProductNotifications_result:
17077 
  """
17078 
  Attributes:
17079 
   - success
17080 
  """
17081 
 
17082 
  thrift_spec = (
17083 
    (0, TType.BOOL, 'success', None, None, ), # 0
17084 
  )
17085 
 
17086 
  def __init__(self, success=None,):
17087 
    self.success = success
17088 
 
17089 
  def read(self, iprot):
17090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17092 
      return
17093 
    iprot.readStructBegin()
17094 
    while True:
17095 
      (fname, ftype, fid) = iprot.readFieldBegin()
17096 
      if ftype == TType.STOP:
17097 
        break
17098 
      if fid == 0:
17099 
        if ftype == TType.BOOL:
17100 
          self.success = iprot.readBool();
17101 
        else:
17102 
          iprot.skip(ftype)
17103 
      else:
17104 
        iprot.skip(ftype)
17105 
      iprot.readFieldEnd()
17106 
    iprot.readStructEnd()
17107 
 
17108 
  def write(self, oprot):
17109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17111 
      return
17112 
    oprot.writeStructBegin('sendProductNotifications_result')
17113 
    if self.success is not None:
17114 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17115 
      oprot.writeBool(self.success)
17116 
      oprot.writeFieldEnd()
17117 
    oprot.writeFieldStop()
17118 
    oprot.writeStructEnd()
17119 
 
17120 
  def validate(self):
17121 
    return
17122 
 
17123 
 
17124 
  def __repr__(self):
17125 
    L = ['%s=%r' % (key, value)
17126 
      for key, value in self.__dict__.iteritems()]
17127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17128 
 
17129 
  def __eq__(self, other):
17130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17131 
 
17132 
  def __ne__(self, other):
17133 
    return not (self == other)
17134 
 
17135 
class getAllBrandsByCategory_args:
17136 
  """
17137 
  Attributes:
17138 
   - categoryId
17139 
  """
17140 
 
17141 
  thrift_spec = (
17142 
    None, # 0
17143 
    (1, TType.I64, 'categoryId', None, None, ), # 1
17144 
  )
17145 
 
17146 
  def __init__(self, categoryId=None,):
17147 
    self.categoryId = categoryId
17148 
 
17149 
  def read(self, iprot):
17150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17152 
      return
17153 
    iprot.readStructBegin()
17154 
    while True:
17155 
      (fname, ftype, fid) = iprot.readFieldBegin()
17156 
      if ftype == TType.STOP:
17157 
        break
17158 
      if fid == 1:
17159 
        if ftype == TType.I64:
17160 
          self.categoryId = iprot.readI64();
17161 
        else:
17162 
          iprot.skip(ftype)
17163 
      else:
17164 
        iprot.skip(ftype)
17165 
      iprot.readFieldEnd()
17166 
    iprot.readStructEnd()
17167 
 
17168 
  def write(self, oprot):
17169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17171 
      return
17172 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
17173 
    if self.categoryId is not None:
17174 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
17175 
      oprot.writeI64(self.categoryId)
17176 
      oprot.writeFieldEnd()
17177 
    oprot.writeFieldStop()
17178 
    oprot.writeStructEnd()
17179 
 
17180 
  def validate(self):
17181 
    return
17182 
 
17183 
 
17184 
  def __repr__(self):
17185 
    L = ['%s=%r' % (key, value)
17186 
      for key, value in self.__dict__.iteritems()]
17187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17188 
 
17189 
  def __eq__(self, other):
17190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17191 
 
17192 
  def __ne__(self, other):
17193 
    return not (self == other)
17194 
 
17195 
class getAllBrandsByCategory_result:
17196 
  """
17197 
  Attributes:
17198 
   - success
17199 
  """
17200 
 
17201 
  thrift_spec = (
17202 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
17203 
  )
17204 
 
17205 
  def __init__(self, success=None,):
17206 
    self.success = success
17207 
 
17208 
  def read(self, iprot):
17209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17211 
      return
17212 
    iprot.readStructBegin()
17213 
    while True:
17214 
      (fname, ftype, fid) = iprot.readFieldBegin()
17215 
      if ftype == TType.STOP:
17216 
        break
17217 
      if fid == 0:
17218 
        if ftype == TType.LIST:
17219 
          self.success = []
9155 kshitij.so 17220 
          (_etype300, _size297) = iprot.readListBegin()
17221 
          for _i301 in xrange(_size297):
17222 
            _elem302 = iprot.readString();
17223 
            self.success.append(_elem302)
5944 mandeep.dh 17224 
          iprot.readListEnd()
17225 
        else:
17226 
          iprot.skip(ftype)
17227 
      else:
17228 
        iprot.skip(ftype)
17229 
      iprot.readFieldEnd()
17230 
    iprot.readStructEnd()
17231 
 
17232 
  def write(self, oprot):
17233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17235 
      return
17236 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
17237 
    if self.success is not None:
17238 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17239 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 17240 
      for iter303 in self.success:
17241 
        oprot.writeString(iter303)
5944 mandeep.dh 17242 
      oprot.writeListEnd()
17243 
      oprot.writeFieldEnd()
17244 
    oprot.writeFieldStop()
17245 
    oprot.writeStructEnd()
17246 
 
17247 
  def validate(self):
17248 
    return
17249 
 
17250 
 
17251 
  def __repr__(self):
17252 
    L = ['%s=%r' % (key, value)
17253 
      for key, value in self.__dict__.iteritems()]
17254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17255 
 
17256 
  def __eq__(self, other):
17257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17258 
 
17259 
  def __ne__(self, other):
17260 
    return not (self == other)
17261 
 
17262 
class getAllBrands_args:
17263 
 
17264 
  thrift_spec = (
17265 
  )
17266 
 
17267 
  def read(self, iprot):
17268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17270 
      return
17271 
    iprot.readStructBegin()
17272 
    while True:
17273 
      (fname, ftype, fid) = iprot.readFieldBegin()
17274 
      if ftype == TType.STOP:
17275 
        break
17276 
      else:
17277 
        iprot.skip(ftype)
17278 
      iprot.readFieldEnd()
17279 
    iprot.readStructEnd()
17280 
 
17281 
  def write(self, oprot):
17282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17284 
      return
17285 
    oprot.writeStructBegin('getAllBrands_args')
17286 
    oprot.writeFieldStop()
17287 
    oprot.writeStructEnd()
17288 
 
17289 
  def validate(self):
17290 
    return
17291 
 
17292 
 
17293 
  def __repr__(self):
17294 
    L = ['%s=%r' % (key, value)
17295 
      for key, value in self.__dict__.iteritems()]
17296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17297 
 
17298 
  def __eq__(self, other):
17299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17300 
 
17301 
  def __ne__(self, other):
17302 
    return not (self == other)
17303 
 
17304 
class getAllBrands_result:
17305 
  """
17306 
  Attributes:
17307 
   - success
17308 
  """
17309 
 
17310 
  thrift_spec = (
17311 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
17312 
  )
17313 
 
17314 
  def __init__(self, success=None,):
17315 
    self.success = success
17316 
 
17317 
  def read(self, iprot):
17318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17320 
      return
17321 
    iprot.readStructBegin()
17322 
    while True:
17323 
      (fname, ftype, fid) = iprot.readFieldBegin()
17324 
      if ftype == TType.STOP:
17325 
        break
17326 
      if fid == 0:
17327 
        if ftype == TType.LIST:
17328 
          self.success = []
9155 kshitij.so 17329 
          (_etype307, _size304) = iprot.readListBegin()
17330 
          for _i308 in xrange(_size304):
17331 
            _elem309 = iprot.readString();
17332 
            self.success.append(_elem309)
5944 mandeep.dh 17333 
          iprot.readListEnd()
17334 
        else:
17335 
          iprot.skip(ftype)
17336 
      else:
17337 
        iprot.skip(ftype)
17338 
      iprot.readFieldEnd()
17339 
    iprot.readStructEnd()
17340 
 
17341 
  def write(self, oprot):
17342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17344 
      return
17345 
    oprot.writeStructBegin('getAllBrands_result')
17346 
    if self.success is not None:
17347 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17348 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 17349 
      for iter310 in self.success:
17350 
        oprot.writeString(iter310)
5944 mandeep.dh 17351 
      oprot.writeListEnd()
17352 
      oprot.writeFieldEnd()
17353 
    oprot.writeFieldStop()
17354 
    oprot.writeStructEnd()
17355 
 
17356 
  def validate(self):
17357 
    return
17358 
 
17359 
 
17360 
  def __repr__(self):
17361 
    L = ['%s=%r' % (key, value)
17362 
      for key, value in self.__dict__.iteritems()]
17363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17364 
 
17365 
  def __eq__(self, other):
17366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17367 
 
17368 
  def __ne__(self, other):
17369 
    return not (self == other)
17370 
 
17371 
class getAllSources_args:
17372 
 
17373 
  thrift_spec = (
17374 
  )
17375 
 
17376 
  def read(self, iprot):
17377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17379 
      return
17380 
    iprot.readStructBegin()
17381 
    while True:
17382 
      (fname, ftype, fid) = iprot.readFieldBegin()
17383 
      if ftype == TType.STOP:
17384 
        break
17385 
      else:
17386 
        iprot.skip(ftype)
17387 
      iprot.readFieldEnd()
17388 
    iprot.readStructEnd()
17389 
 
17390 
  def write(self, oprot):
17391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17393 
      return
17394 
    oprot.writeStructBegin('getAllSources_args')
17395 
    oprot.writeFieldStop()
17396 
    oprot.writeStructEnd()
17397 
 
17398 
  def validate(self):
17399 
    return
17400 
 
17401 
 
17402 
  def __repr__(self):
17403 
    L = ['%s=%r' % (key, value)
17404 
      for key, value in self.__dict__.iteritems()]
17405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17406 
 
17407 
  def __eq__(self, other):
17408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17409 
 
17410 
  def __ne__(self, other):
17411 
    return not (self == other)
17412 
 
17413 
class getAllSources_result:
17414 
  """
17415 
  Attributes:
17416 
   - success
17417 
  """
17418 
 
17419 
  thrift_spec = (
17420 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
17421 
  )
17422 
 
17423 
  def __init__(self, success=None,):
17424 
    self.success = success
17425 
 
17426 
  def read(self, iprot):
17427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17429 
      return
17430 
    iprot.readStructBegin()
17431 
    while True:
17432 
      (fname, ftype, fid) = iprot.readFieldBegin()
17433 
      if ftype == TType.STOP:
17434 
        break
17435 
      if fid == 0:
17436 
        if ftype == TType.LIST:
17437 
          self.success = []
9155 kshitij.so 17438 
          (_etype314, _size311) = iprot.readListBegin()
17439 
          for _i315 in xrange(_size311):
17440 
            _elem316 = Source()
17441 
            _elem316.read(iprot)
17442 
            self.success.append(_elem316)
5944 mandeep.dh 17443 
          iprot.readListEnd()
17444 
        else:
17445 
          iprot.skip(ftype)
17446 
      else:
17447 
        iprot.skip(ftype)
17448 
      iprot.readFieldEnd()
17449 
    iprot.readStructEnd()
17450 
 
17451 
  def write(self, oprot):
17452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17454 
      return
17455 
    oprot.writeStructBegin('getAllSources_result')
17456 
    if self.success is not None:
17457 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17458 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17459 
      for iter317 in self.success:
17460 
        iter317.write(oprot)
5944 mandeep.dh 17461 
      oprot.writeListEnd()
17462 
      oprot.writeFieldEnd()
17463 
    oprot.writeFieldStop()
17464 
    oprot.writeStructEnd()
17465 
 
17466 
  def validate(self):
17467 
    return
17468 
 
17469 
 
17470 
  def __repr__(self):
17471 
    L = ['%s=%r' % (key, value)
17472 
      for key, value in self.__dict__.iteritems()]
17473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17474 
 
17475 
  def __eq__(self, other):
17476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17477 
 
17478 
  def __ne__(self, other):
17479 
    return not (self == other)
17480 
 
17481 
class getItemPricingBySource_args:
17482 
  """
17483 
  Attributes:
17484 
   - itemId
17485 
   - sourceId
17486 
  """
17487 
 
17488 
  thrift_spec = (
17489 
    None, # 0
17490 
    (1, TType.I64, 'itemId', None, None, ), # 1
17491 
    (2, TType.I64, 'sourceId', None, None, ), # 2
17492 
  )
17493 
 
17494 
  def __init__(self, itemId=None, sourceId=None,):
17495 
    self.itemId = itemId
17496 
    self.sourceId = sourceId
17497 
 
17498 
  def read(self, iprot):
17499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17501 
      return
17502 
    iprot.readStructBegin()
17503 
    while True:
17504 
      (fname, ftype, fid) = iprot.readFieldBegin()
17505 
      if ftype == TType.STOP:
17506 
        break
17507 
      if fid == 1:
17508 
        if ftype == TType.I64:
17509 
          self.itemId = iprot.readI64();
17510 
        else:
17511 
          iprot.skip(ftype)
17512 
      elif fid == 2:
17513 
        if ftype == TType.I64:
17514 
          self.sourceId = iprot.readI64();
17515 
        else:
17516 
          iprot.skip(ftype)
17517 
      else:
17518 
        iprot.skip(ftype)
17519 
      iprot.readFieldEnd()
17520 
    iprot.readStructEnd()
17521 
 
17522 
  def write(self, oprot):
17523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17525 
      return
17526 
    oprot.writeStructBegin('getItemPricingBySource_args')
17527 
    if self.itemId is not None:
17528 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17529 
      oprot.writeI64(self.itemId)
17530 
      oprot.writeFieldEnd()
17531 
    if self.sourceId is not None:
17532 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
17533 
      oprot.writeI64(self.sourceId)
17534 
      oprot.writeFieldEnd()
17535 
    oprot.writeFieldStop()
17536 
    oprot.writeStructEnd()
17537 
 
17538 
  def validate(self):
17539 
    return
17540 
 
17541 
 
17542 
  def __repr__(self):
17543 
    L = ['%s=%r' % (key, value)
17544 
      for key, value in self.__dict__.iteritems()]
17545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17546 
 
17547 
  def __eq__(self, other):
17548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17549 
 
17550 
  def __ne__(self, other):
17551 
    return not (self == other)
17552 
 
17553 
class getItemPricingBySource_result:
17554 
  """
17555 
  Attributes:
17556 
   - success
17557 
   - cex
17558 
  """
17559 
 
17560 
  thrift_spec = (
17561 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
17562 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17563 
  )
17564 
 
17565 
  def __init__(self, success=None, cex=None,):
17566 
    self.success = success
17567 
    self.cex = cex
17568 
 
17569 
  def read(self, iprot):
17570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17572 
      return
17573 
    iprot.readStructBegin()
17574 
    while True:
17575 
      (fname, ftype, fid) = iprot.readFieldBegin()
17576 
      if ftype == TType.STOP:
17577 
        break
17578 
      if fid == 0:
17579 
        if ftype == TType.STRUCT:
17580 
          self.success = SourceItemPricing()
17581 
          self.success.read(iprot)
17582 
        else:
17583 
          iprot.skip(ftype)
17584 
      elif fid == 1:
17585 
        if ftype == TType.STRUCT:
17586 
          self.cex = CatalogServiceException()
17587 
          self.cex.read(iprot)
17588 
        else:
17589 
          iprot.skip(ftype)
17590 
      else:
17591 
        iprot.skip(ftype)
17592 
      iprot.readFieldEnd()
17593 
    iprot.readStructEnd()
17594 
 
17595 
  def write(self, oprot):
17596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17598 
      return
17599 
    oprot.writeStructBegin('getItemPricingBySource_result')
17600 
    if self.success is not None:
17601 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17602 
      self.success.write(oprot)
17603 
      oprot.writeFieldEnd()
17604 
    if self.cex is not None:
17605 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17606 
      self.cex.write(oprot)
17607 
      oprot.writeFieldEnd()
17608 
    oprot.writeFieldStop()
17609 
    oprot.writeStructEnd()
17610 
 
17611 
  def validate(self):
17612 
    return
17613 
 
17614 
 
17615 
  def __repr__(self):
17616 
    L = ['%s=%r' % (key, value)
17617 
      for key, value in self.__dict__.iteritems()]
17618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17619 
 
17620 
  def __eq__(self, other):
17621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17622 
 
17623 
  def __ne__(self, other):
17624 
    return not (self == other)
17625 
 
17626 
class addSourceItemPricing_args:
17627 
  """
17628 
  Attributes:
17629 
   - sourceItemPricing
17630 
  """
17631 
 
17632 
  thrift_spec = (
17633 
    None, # 0
17634 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
17635 
  )
17636 
 
17637 
  def __init__(self, sourceItemPricing=None,):
17638 
    self.sourceItemPricing = sourceItemPricing
17639 
 
17640 
  def read(self, iprot):
17641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17643 
      return
17644 
    iprot.readStructBegin()
17645 
    while True:
17646 
      (fname, ftype, fid) = iprot.readFieldBegin()
17647 
      if ftype == TType.STOP:
17648 
        break
17649 
      if fid == 1:
17650 
        if ftype == TType.STRUCT:
17651 
          self.sourceItemPricing = SourceItemPricing()
17652 
          self.sourceItemPricing.read(iprot)
17653 
        else:
17654 
          iprot.skip(ftype)
17655 
      else:
17656 
        iprot.skip(ftype)
17657 
      iprot.readFieldEnd()
17658 
    iprot.readStructEnd()
17659 
 
17660 
  def write(self, oprot):
17661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17663 
      return
17664 
    oprot.writeStructBegin('addSourceItemPricing_args')
17665 
    if self.sourceItemPricing is not None:
17666 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
17667 
      self.sourceItemPricing.write(oprot)
17668 
      oprot.writeFieldEnd()
17669 
    oprot.writeFieldStop()
17670 
    oprot.writeStructEnd()
17671 
 
17672 
  def validate(self):
17673 
    return
17674 
 
17675 
 
17676 
  def __repr__(self):
17677 
    L = ['%s=%r' % (key, value)
17678 
      for key, value in self.__dict__.iteritems()]
17679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17680 
 
17681 
  def __eq__(self, other):
17682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17683 
 
17684 
  def __ne__(self, other):
17685 
    return not (self == other)
17686 
 
17687 
class addSourceItemPricing_result:
17688 
  """
17689 
  Attributes:
17690 
   - cex
17691 
  """
17692 
 
17693 
  thrift_spec = (
17694 
    None, # 0
17695 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17696 
  )
17697 
 
17698 
  def __init__(self, cex=None,):
17699 
    self.cex = cex
17700 
 
17701 
  def read(self, iprot):
17702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17704 
      return
17705 
    iprot.readStructBegin()
17706 
    while True:
17707 
      (fname, ftype, fid) = iprot.readFieldBegin()
17708 
      if ftype == TType.STOP:
17709 
        break
17710 
      if fid == 1:
17711 
        if ftype == TType.STRUCT:
17712 
          self.cex = CatalogServiceException()
17713 
          self.cex.read(iprot)
17714 
        else:
17715 
          iprot.skip(ftype)
17716 
      else:
17717 
        iprot.skip(ftype)
17718 
      iprot.readFieldEnd()
17719 
    iprot.readStructEnd()
17720 
 
17721 
  def write(self, oprot):
17722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17724 
      return
17725 
    oprot.writeStructBegin('addSourceItemPricing_result')
17726 
    if self.cex is not None:
17727 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17728 
      self.cex.write(oprot)
17729 
      oprot.writeFieldEnd()
17730 
    oprot.writeFieldStop()
17731 
    oprot.writeStructEnd()
17732 
 
17733 
  def validate(self):
17734 
    return
17735 
 
17736 
 
17737 
  def __repr__(self):
17738 
    L = ['%s=%r' % (key, value)
17739 
      for key, value in self.__dict__.iteritems()]
17740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17741 
 
17742 
  def __eq__(self, other):
17743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17744 
 
17745 
  def __ne__(self, other):
17746 
    return not (self == other)
17747 
 
17748 
class getAllSourcePricing_args:
17749 
  """
17750 
  Attributes:
17751 
   - itemId
17752 
  """
17753 
 
17754 
  thrift_spec = (
17755 
    None, # 0
17756 
    (1, TType.I64, 'itemId', None, None, ), # 1
17757 
  )
17758 
 
17759 
  def __init__(self, itemId=None,):
17760 
    self.itemId = itemId
17761 
 
17762 
  def read(self, iprot):
17763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17765 
      return
17766 
    iprot.readStructBegin()
17767 
    while True:
17768 
      (fname, ftype, fid) = iprot.readFieldBegin()
17769 
      if ftype == TType.STOP:
17770 
        break
17771 
      if fid == 1:
17772 
        if ftype == TType.I64:
17773 
          self.itemId = iprot.readI64();
17774 
        else:
17775 
          iprot.skip(ftype)
17776 
      else:
17777 
        iprot.skip(ftype)
17778 
      iprot.readFieldEnd()
17779 
    iprot.readStructEnd()
17780 
 
17781 
  def write(self, oprot):
17782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17784 
      return
17785 
    oprot.writeStructBegin('getAllSourcePricing_args')
17786 
    if self.itemId is not None:
17787 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17788 
      oprot.writeI64(self.itemId)
17789 
      oprot.writeFieldEnd()
17790 
    oprot.writeFieldStop()
17791 
    oprot.writeStructEnd()
17792 
 
17793 
  def validate(self):
17794 
    return
17795 
 
17796 
 
17797 
  def __repr__(self):
17798 
    L = ['%s=%r' % (key, value)
17799 
      for key, value in self.__dict__.iteritems()]
17800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17801 
 
17802 
  def __eq__(self, other):
17803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17804 
 
17805 
  def __ne__(self, other):
17806 
    return not (self == other)
17807 
 
17808 
class getAllSourcePricing_result:
17809 
  """
17810 
  Attributes:
17811 
   - success
17812 
   - cex
17813 
  """
17814 
 
17815 
  thrift_spec = (
17816 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
17817 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17818 
  )
17819 
 
17820 
  def __init__(self, success=None, cex=None,):
17821 
    self.success = success
17822 
    self.cex = cex
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 == 0:
17834 
        if ftype == TType.LIST:
17835 
          self.success = []
9155 kshitij.so 17836 
          (_etype321, _size318) = iprot.readListBegin()
17837 
          for _i322 in xrange(_size318):
17838 
            _elem323 = SourceItemPricing()
17839 
            _elem323.read(iprot)
17840 
            self.success.append(_elem323)
5944 mandeep.dh 17841 
          iprot.readListEnd()
17842 
        else:
17843 
          iprot.skip(ftype)
17844 
      elif fid == 1:
17845 
        if ftype == TType.STRUCT:
17846 
          self.cex = CatalogServiceException()
17847 
          self.cex.read(iprot)
17848 
        else:
17849 
          iprot.skip(ftype)
17850 
      else:
17851 
        iprot.skip(ftype)
17852 
      iprot.readFieldEnd()
17853 
    iprot.readStructEnd()
17854 
 
17855 
  def write(self, oprot):
17856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17858 
      return
17859 
    oprot.writeStructBegin('getAllSourcePricing_result')
17860 
    if self.success is not None:
17861 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17862 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17863 
      for iter324 in self.success:
17864 
        iter324.write(oprot)
5944 mandeep.dh 17865 
      oprot.writeListEnd()
17866 
      oprot.writeFieldEnd()
17867 
    if self.cex is not None:
17868 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17869 
      self.cex.write(oprot)
17870 
      oprot.writeFieldEnd()
17871 
    oprot.writeFieldStop()
17872 
    oprot.writeStructEnd()
17873 
 
17874 
  def validate(self):
17875 
    return
17876 
 
17877 
 
17878 
  def __repr__(self):
17879 
    L = ['%s=%r' % (key, value)
17880 
      for key, value in self.__dict__.iteritems()]
17881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17882 
 
17883 
  def __eq__(self, other):
17884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17885 
 
17886 
  def __ne__(self, other):
17887 
    return not (self == other)
17888 
 
17889 
class getItemForSource_args:
17890 
  """
17891 
  Attributes:
17892 
   - item_id
17893 
   - sourceId
17894 
  """
17895 
 
17896 
  thrift_spec = (
17897 
    None, # 0
17898 
    (1, TType.I64, 'item_id', None, None, ), # 1
17899 
    (2, TType.I64, 'sourceId', None, None, ), # 2
17900 
  )
17901 
 
17902 
  def __init__(self, item_id=None, sourceId=None,):
17903 
    self.item_id = item_id
17904 
    self.sourceId = sourceId
17905 
 
17906 
  def read(self, iprot):
17907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17909 
      return
17910 
    iprot.readStructBegin()
17911 
    while True:
17912 
      (fname, ftype, fid) = iprot.readFieldBegin()
17913 
      if ftype == TType.STOP:
17914 
        break
17915 
      if fid == 1:
17916 
        if ftype == TType.I64:
17917 
          self.item_id = iprot.readI64();
17918 
        else:
17919 
          iprot.skip(ftype)
17920 
      elif fid == 2:
17921 
        if ftype == TType.I64:
17922 
          self.sourceId = iprot.readI64();
17923 
        else:
17924 
          iprot.skip(ftype)
17925 
      else:
17926 
        iprot.skip(ftype)
17927 
      iprot.readFieldEnd()
17928 
    iprot.readStructEnd()
17929 
 
17930 
  def write(self, oprot):
17931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17933 
      return
17934 
    oprot.writeStructBegin('getItemForSource_args')
17935 
    if self.item_id is not None:
17936 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
17937 
      oprot.writeI64(self.item_id)
17938 
      oprot.writeFieldEnd()
17939 
    if self.sourceId is not None:
17940 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
17941 
      oprot.writeI64(self.sourceId)
17942 
      oprot.writeFieldEnd()
17943 
    oprot.writeFieldStop()
17944 
    oprot.writeStructEnd()
17945 
 
17946 
  def validate(self):
17947 
    return
17948 
 
17949 
 
17950 
  def __repr__(self):
17951 
    L = ['%s=%r' % (key, value)
17952 
      for key, value in self.__dict__.iteritems()]
17953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17954 
 
17955 
  def __eq__(self, other):
17956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17957 
 
17958 
  def __ne__(self, other):
17959 
    return not (self == other)
17960 
 
17961 
class getItemForSource_result:
17962 
  """
17963 
  Attributes:
17964 
   - success
17965 
   - cex
17966 
  """
17967 
 
17968 
  thrift_spec = (
17969 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
17970 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17971 
  )
17972 
 
17973 
  def __init__(self, success=None, cex=None,):
17974 
    self.success = success
17975 
    self.cex = cex
17976 
 
17977 
  def read(self, iprot):
17978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17980 
      return
17981 
    iprot.readStructBegin()
17982 
    while True:
17983 
      (fname, ftype, fid) = iprot.readFieldBegin()
17984 
      if ftype == TType.STOP:
17985 
        break
17986 
      if fid == 0:
17987 
        if ftype == TType.STRUCT:
17988 
          self.success = Item()
17989 
          self.success.read(iprot)
17990 
        else:
17991 
          iprot.skip(ftype)
17992 
      elif fid == 1:
17993 
        if ftype == TType.STRUCT:
17994 
          self.cex = CatalogServiceException()
17995 
          self.cex.read(iprot)
17996 
        else:
17997 
          iprot.skip(ftype)
17998 
      else:
17999 
        iprot.skip(ftype)
18000 
      iprot.readFieldEnd()
18001 
    iprot.readStructEnd()
18002 
 
18003 
  def write(self, oprot):
18004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18006 
      return
18007 
    oprot.writeStructBegin('getItemForSource_result')
18008 
    if self.success is not None:
18009 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18010 
      self.success.write(oprot)
18011 
      oprot.writeFieldEnd()
18012 
    if self.cex is not None:
18013 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18014 
      self.cex.write(oprot)
18015 
      oprot.writeFieldEnd()
18016 
    oprot.writeFieldStop()
18017 
    oprot.writeStructEnd()
18018 
 
18019 
  def validate(self):
18020 
    return
18021 
 
18022 
 
18023 
  def __repr__(self):
18024 
    L = ['%s=%r' % (key, value)
18025 
      for key, value in self.__dict__.iteritems()]
18026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18027 
 
18028 
  def __eq__(self, other):
18029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18030 
 
18031 
  def __ne__(self, other):
18032 
    return not (self == other)
18033 
 
18034 
class searchItemsInRange_args:
18035 
  """
18036 
  Attributes:
18037 
   - searchTerms
18038 
   - offset
18039 
   - limit
18040 
  """
18041 
 
18042 
  thrift_spec = (
18043 
    None, # 0
18044 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
18045 
    (2, TType.I64, 'offset', None, None, ), # 2
18046 
    (3, TType.I64, 'limit', None, None, ), # 3
18047 
  )
18048 
 
18049 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
18050 
    self.searchTerms = searchTerms
18051 
    self.offset = offset
18052 
    self.limit = limit
18053 
 
18054 
  def read(self, iprot):
18055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18057 
      return
18058 
    iprot.readStructBegin()
18059 
    while True:
18060 
      (fname, ftype, fid) = iprot.readFieldBegin()
18061 
      if ftype == TType.STOP:
18062 
        break
18063 
      if fid == 1:
18064 
        if ftype == TType.LIST:
18065 
          self.searchTerms = []
9155 kshitij.so 18066 
          (_etype328, _size325) = iprot.readListBegin()
18067 
          for _i329 in xrange(_size325):
18068 
            _elem330 = iprot.readString();
18069 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 18070 
          iprot.readListEnd()
18071 
        else:
18072 
          iprot.skip(ftype)
18073 
      elif fid == 2:
18074 
        if ftype == TType.I64:
18075 
          self.offset = iprot.readI64();
18076 
        else:
18077 
          iprot.skip(ftype)
18078 
      elif fid == 3:
18079 
        if ftype == TType.I64:
18080 
          self.limit = iprot.readI64();
18081 
        else:
18082 
          iprot.skip(ftype)
18083 
      else:
18084 
        iprot.skip(ftype)
18085 
      iprot.readFieldEnd()
18086 
    iprot.readStructEnd()
18087 
 
18088 
  def write(self, oprot):
18089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18091 
      return
18092 
    oprot.writeStructBegin('searchItemsInRange_args')
18093 
    if self.searchTerms is not None:
18094 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
18095 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 18096 
      for iter331 in self.searchTerms:
18097 
        oprot.writeString(iter331)
5944 mandeep.dh 18098 
      oprot.writeListEnd()
18099 
      oprot.writeFieldEnd()
18100 
    if self.offset is not None:
18101 
      oprot.writeFieldBegin('offset', TType.I64, 2)
18102 
      oprot.writeI64(self.offset)
18103 
      oprot.writeFieldEnd()
18104 
    if self.limit is not None:
18105 
      oprot.writeFieldBegin('limit', TType.I64, 3)
18106 
      oprot.writeI64(self.limit)
18107 
      oprot.writeFieldEnd()
18108 
    oprot.writeFieldStop()
18109 
    oprot.writeStructEnd()
18110 
 
18111 
  def validate(self):
18112 
    return
18113 
 
18114 
 
18115 
  def __repr__(self):
18116 
    L = ['%s=%r' % (key, value)
18117 
      for key, value in self.__dict__.iteritems()]
18118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18119 
 
18120 
  def __eq__(self, other):
18121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18122 
 
18123 
  def __ne__(self, other):
18124 
    return not (self == other)
18125 
 
18126 
class searchItemsInRange_result:
18127 
  """
18128 
  Attributes:
18129 
   - success
18130 
  """
18131 
 
18132 
  thrift_spec = (
18133 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18134 
  )
18135 
 
18136 
  def __init__(self, success=None,):
18137 
    self.success = success
18138 
 
18139 
  def read(self, iprot):
18140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18142 
      return
18143 
    iprot.readStructBegin()
18144 
    while True:
18145 
      (fname, ftype, fid) = iprot.readFieldBegin()
18146 
      if ftype == TType.STOP:
18147 
        break
18148 
      if fid == 0:
18149 
        if ftype == TType.LIST:
18150 
          self.success = []
9155 kshitij.so 18151 
          (_etype335, _size332) = iprot.readListBegin()
18152 
          for _i336 in xrange(_size332):
18153 
            _elem337 = Item()
18154 
            _elem337.read(iprot)
18155 
            self.success.append(_elem337)
5944 mandeep.dh 18156 
          iprot.readListEnd()
18157 
        else:
18158 
          iprot.skip(ftype)
18159 
      else:
18160 
        iprot.skip(ftype)
18161 
      iprot.readFieldEnd()
18162 
    iprot.readStructEnd()
18163 
 
18164 
  def write(self, oprot):
18165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18167 
      return
18168 
    oprot.writeStructBegin('searchItemsInRange_result')
18169 
    if self.success is not None:
18170 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18171 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18172 
      for iter338 in self.success:
18173 
        iter338.write(oprot)
5944 mandeep.dh 18174 
      oprot.writeListEnd()
18175 
      oprot.writeFieldEnd()
18176 
    oprot.writeFieldStop()
18177 
    oprot.writeStructEnd()
18178 
 
18179 
  def validate(self):
18180 
    return
18181 
 
18182 
 
18183 
  def __repr__(self):
18184 
    L = ['%s=%r' % (key, value)
18185 
      for key, value in self.__dict__.iteritems()]
18186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18187 
 
18188 
  def __eq__(self, other):
18189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18190 
 
18191 
  def __ne__(self, other):
18192 
    return not (self == other)
18193 
 
18194 
class getSearchResultCount_args:
18195 
  """
18196 
  Attributes:
18197 
   - searchTerms
18198 
  """
18199 
 
18200 
  thrift_spec = (
18201 
    None, # 0
18202 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
18203 
  )
18204 
 
18205 
  def __init__(self, searchTerms=None,):
18206 
    self.searchTerms = searchTerms
18207 
 
18208 
  def read(self, iprot):
18209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18211 
      return
18212 
    iprot.readStructBegin()
18213 
    while True:
18214 
      (fname, ftype, fid) = iprot.readFieldBegin()
18215 
      if ftype == TType.STOP:
18216 
        break
18217 
      if fid == 1:
18218 
        if ftype == TType.LIST:
18219 
          self.searchTerms = []
9155 kshitij.so 18220 
          (_etype342, _size339) = iprot.readListBegin()
18221 
          for _i343 in xrange(_size339):
18222 
            _elem344 = iprot.readString();
18223 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 18224 
          iprot.readListEnd()
18225 
        else:
18226 
          iprot.skip(ftype)
18227 
      else:
18228 
        iprot.skip(ftype)
18229 
      iprot.readFieldEnd()
18230 
    iprot.readStructEnd()
18231 
 
18232 
  def write(self, oprot):
18233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18235 
      return
18236 
    oprot.writeStructBegin('getSearchResultCount_args')
18237 
    if self.searchTerms is not None:
18238 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
18239 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 18240 
      for iter345 in self.searchTerms:
18241 
        oprot.writeString(iter345)
5944 mandeep.dh 18242 
      oprot.writeListEnd()
18243 
      oprot.writeFieldEnd()
18244 
    oprot.writeFieldStop()
18245 
    oprot.writeStructEnd()
18246 
 
18247 
  def validate(self):
18248 
    return
18249 
 
18250 
 
18251 
  def __repr__(self):
18252 
    L = ['%s=%r' % (key, value)
18253 
      for key, value in self.__dict__.iteritems()]
18254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18255 
 
18256 
  def __eq__(self, other):
18257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18258 
 
18259 
  def __ne__(self, other):
18260 
    return not (self == other)
18261 
 
18262 
class getSearchResultCount_result:
18263 
  """
18264 
  Attributes:
18265 
   - success
18266 
  """
18267 
 
18268 
  thrift_spec = (
18269 
    (0, TType.I32, 'success', None, None, ), # 0
18270 
  )
18271 
 
18272 
  def __init__(self, success=None,):
18273 
    self.success = success
18274 
 
18275 
  def read(self, iprot):
18276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18278 
      return
18279 
    iprot.readStructBegin()
18280 
    while True:
18281 
      (fname, ftype, fid) = iprot.readFieldBegin()
18282 
      if ftype == TType.STOP:
18283 
        break
18284 
      if fid == 0:
18285 
        if ftype == TType.I32:
18286 
          self.success = iprot.readI32();
18287 
        else:
18288 
          iprot.skip(ftype)
18289 
      else:
18290 
        iprot.skip(ftype)
18291 
      iprot.readFieldEnd()
18292 
    iprot.readStructEnd()
18293 
 
18294 
  def write(self, oprot):
18295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18297 
      return
18298 
    oprot.writeStructBegin('getSearchResultCount_result')
18299 
    if self.success is not None:
18300 
      oprot.writeFieldBegin('success', TType.I32, 0)
18301 
      oprot.writeI32(self.success)
18302 
      oprot.writeFieldEnd()
18303 
    oprot.writeFieldStop()
18304 
    oprot.writeStructEnd()
18305 
 
18306 
  def validate(self):
18307 
    return
18308 
 
18309 
 
18310 
  def __repr__(self):
18311 
    L = ['%s=%r' % (key, value)
18312 
      for key, value in self.__dict__.iteritems()]
18313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18314 
 
18315 
  def __eq__(self, other):
18316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18317 
 
18318 
  def __ne__(self, other):
18319 
    return not (self == other)
18320 
 
18321 
class getProductNotifications_args:
18322 
  """
18323 
  Attributes:
18324 
   - startDateTime
18325 
  """
18326 
 
18327 
  thrift_spec = (
18328 
    None, # 0
18329 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
18330 
  )
18331 
 
18332 
  def __init__(self, startDateTime=None,):
18333 
    self.startDateTime = startDateTime
18334 
 
18335 
  def read(self, iprot):
18336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18338 
      return
18339 
    iprot.readStructBegin()
18340 
    while True:
18341 
      (fname, ftype, fid) = iprot.readFieldBegin()
18342 
      if ftype == TType.STOP:
18343 
        break
18344 
      if fid == 1:
18345 
        if ftype == TType.I64:
18346 
          self.startDateTime = iprot.readI64();
18347 
        else:
18348 
          iprot.skip(ftype)
18349 
      else:
18350 
        iprot.skip(ftype)
18351 
      iprot.readFieldEnd()
18352 
    iprot.readStructEnd()
18353 
 
18354 
  def write(self, oprot):
18355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18357 
      return
18358 
    oprot.writeStructBegin('getProductNotifications_args')
18359 
    if self.startDateTime is not None:
18360 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
18361 
      oprot.writeI64(self.startDateTime)
18362 
      oprot.writeFieldEnd()
18363 
    oprot.writeFieldStop()
18364 
    oprot.writeStructEnd()
18365 
 
18366 
  def validate(self):
18367 
    return
18368 
 
18369 
 
18370 
  def __repr__(self):
18371 
    L = ['%s=%r' % (key, value)
18372 
      for key, value in self.__dict__.iteritems()]
18373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18374 
 
18375 
  def __eq__(self, other):
18376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18377 
 
18378 
  def __ne__(self, other):
18379 
    return not (self == other)
18380 
 
18381 
class getProductNotifications_result:
18382 
  """
18383 
  Attributes:
18384 
   - success
18385 
  """
18386 
 
18387 
  thrift_spec = (
18388 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
18389 
  )
18390 
 
18391 
  def __init__(self, success=None,):
18392 
    self.success = success
18393 
 
18394 
  def read(self, iprot):
18395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18397 
      return
18398 
    iprot.readStructBegin()
18399 
    while True:
18400 
      (fname, ftype, fid) = iprot.readFieldBegin()
18401 
      if ftype == TType.STOP:
18402 
        break
18403 
      if fid == 0:
18404 
        if ftype == TType.LIST:
18405 
          self.success = []
9155 kshitij.so 18406 
          (_etype349, _size346) = iprot.readListBegin()
18407 
          for _i350 in xrange(_size346):
18408 
            _elem351 = ProductNotificationRequest()
18409 
            _elem351.read(iprot)
18410 
            self.success.append(_elem351)
5944 mandeep.dh 18411 
          iprot.readListEnd()
18412 
        else:
18413 
          iprot.skip(ftype)
18414 
      else:
18415 
        iprot.skip(ftype)
18416 
      iprot.readFieldEnd()
18417 
    iprot.readStructEnd()
18418 
 
18419 
  def write(self, oprot):
18420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18422 
      return
18423 
    oprot.writeStructBegin('getProductNotifications_result')
18424 
    if self.success is not None:
18425 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18426 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18427 
      for iter352 in self.success:
18428 
        iter352.write(oprot)
5944 mandeep.dh 18429 
      oprot.writeListEnd()
18430 
      oprot.writeFieldEnd()
18431 
    oprot.writeFieldStop()
18432 
    oprot.writeStructEnd()
18433 
 
18434 
  def validate(self):
18435 
    return
18436 
 
18437 
 
18438 
  def __repr__(self):
18439 
    L = ['%s=%r' % (key, value)
18440 
      for key, value in self.__dict__.iteritems()]
18441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18442 
 
18443 
  def __eq__(self, other):
18444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18445 
 
18446 
  def __ne__(self, other):
18447 
    return not (self == other)
18448 
 
18449 
class getProductNotificationRequestCount_args:
18450 
  """
18451 
  Attributes:
18452 
   - startDateTime
7897 amar.kumar 18453 
   - categoryId
5944 mandeep.dh 18454 
  """
18455 
 
18456 
  thrift_spec = (
18457 
    None, # 0
18458 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 18459 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 18460 
  )
18461 
 
7897 amar.kumar 18462 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 18463 
    self.startDateTime = startDateTime
7897 amar.kumar 18464 
    self.categoryId = categoryId
5944 mandeep.dh 18465 
 
18466 
  def read(self, iprot):
18467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18469 
      return
18470 
    iprot.readStructBegin()
18471 
    while True:
18472 
      (fname, ftype, fid) = iprot.readFieldBegin()
18473 
      if ftype == TType.STOP:
18474 
        break
18475 
      if fid == 1:
18476 
        if ftype == TType.I64:
18477 
          self.startDateTime = iprot.readI64();
18478 
        else:
18479 
          iprot.skip(ftype)
7897 amar.kumar 18480 
      elif fid == 2:
18481 
        if ftype == TType.I64:
18482 
          self.categoryId = iprot.readI64();
18483 
        else:
18484 
          iprot.skip(ftype)
5944 mandeep.dh 18485 
      else:
18486 
        iprot.skip(ftype)
18487 
      iprot.readFieldEnd()
18488 
    iprot.readStructEnd()
18489 
 
18490 
  def write(self, oprot):
18491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18493 
      return
18494 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
18495 
    if self.startDateTime is not None:
18496 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
18497 
      oprot.writeI64(self.startDateTime)
18498 
      oprot.writeFieldEnd()
7897 amar.kumar 18499 
    if self.categoryId is not None:
18500 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
18501 
      oprot.writeI64(self.categoryId)
18502 
      oprot.writeFieldEnd()
5944 mandeep.dh 18503 
    oprot.writeFieldStop()
18504 
    oprot.writeStructEnd()
18505 
 
18506 
  def validate(self):
18507 
    return
18508 
 
18509 
 
18510 
  def __repr__(self):
18511 
    L = ['%s=%r' % (key, value)
18512 
      for key, value in self.__dict__.iteritems()]
18513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18514 
 
18515 
  def __eq__(self, other):
18516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18517 
 
18518 
  def __ne__(self, other):
18519 
    return not (self == other)
18520 
 
18521 
class getProductNotificationRequestCount_result:
18522 
  """
18523 
  Attributes:
18524 
   - success
18525 
  """
18526 
 
18527 
  thrift_spec = (
18528 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
18529 
  )
18530 
 
18531 
  def __init__(self, success=None,):
18532 
    self.success = success
18533 
 
18534 
  def read(self, iprot):
18535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18537 
      return
18538 
    iprot.readStructBegin()
18539 
    while True:
18540 
      (fname, ftype, fid) = iprot.readFieldBegin()
18541 
      if ftype == TType.STOP:
18542 
        break
18543 
      if fid == 0:
18544 
        if ftype == TType.LIST:
18545 
          self.success = []
9155 kshitij.so 18546 
          (_etype356, _size353) = iprot.readListBegin()
18547 
          for _i357 in xrange(_size353):
18548 
            _elem358 = ProductNotificationRequestCount()
18549 
            _elem358.read(iprot)
18550 
            self.success.append(_elem358)
5944 mandeep.dh 18551 
          iprot.readListEnd()
18552 
        else:
18553 
          iprot.skip(ftype)
18554 
      else:
18555 
        iprot.skip(ftype)
18556 
      iprot.readFieldEnd()
18557 
    iprot.readStructEnd()
18558 
 
18559 
  def write(self, oprot):
18560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18562 
      return
18563 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
18564 
    if self.success is not None:
18565 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18566 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18567 
      for iter359 in self.success:
18568 
        iter359.write(oprot)
5944 mandeep.dh 18569 
      oprot.writeListEnd()
18570 
      oprot.writeFieldEnd()
18571 
    oprot.writeFieldStop()
18572 
    oprot.writeStructEnd()
18573 
 
18574 
  def validate(self):
18575 
    return
18576 
 
18577 
 
18578 
  def __repr__(self):
18579 
    L = ['%s=%r' % (key, value)
18580 
      for key, value in self.__dict__.iteritems()]
18581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18582 
 
18583 
  def __eq__(self, other):
18584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18585 
 
18586 
  def __ne__(self, other):
18587 
    return not (self == other)
18588 
 
18589 
class addAuthorizationLog_args:
18590 
  """
18591 
  Attributes:
18592 
   - itemId
18593 
   - username
18594 
   - reason
18595 
  """
18596 
 
18597 
  thrift_spec = (
18598 
    None, # 0
18599 
    (1, TType.I64, 'itemId', None, None, ), # 1
18600 
    (2, TType.STRING, 'username', None, None, ), # 2
18601 
    (3, TType.STRING, 'reason', None, None, ), # 3
18602 
  )
18603 
 
18604 
  def __init__(self, itemId=None, username=None, reason=None,):
18605 
    self.itemId = itemId
18606 
    self.username = username
18607 
    self.reason = reason
18608 
 
18609 
  def read(self, iprot):
18610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18612 
      return
18613 
    iprot.readStructBegin()
18614 
    while True:
18615 
      (fname, ftype, fid) = iprot.readFieldBegin()
18616 
      if ftype == TType.STOP:
18617 
        break
18618 
      if fid == 1:
18619 
        if ftype == TType.I64:
18620 
          self.itemId = iprot.readI64();
18621 
        else:
18622 
          iprot.skip(ftype)
18623 
      elif fid == 2:
18624 
        if ftype == TType.STRING:
18625 
          self.username = iprot.readString();
18626 
        else:
18627 
          iprot.skip(ftype)
18628 
      elif fid == 3:
18629 
        if ftype == TType.STRING:
18630 
          self.reason = iprot.readString();
18631 
        else:
18632 
          iprot.skip(ftype)
18633 
      else:
18634 
        iprot.skip(ftype)
18635 
      iprot.readFieldEnd()
18636 
    iprot.readStructEnd()
18637 
 
18638 
  def write(self, oprot):
18639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18641 
      return
18642 
    oprot.writeStructBegin('addAuthorizationLog_args')
18643 
    if self.itemId is not None:
18644 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18645 
      oprot.writeI64(self.itemId)
18646 
      oprot.writeFieldEnd()
18647 
    if self.username is not None:
18648 
      oprot.writeFieldBegin('username', TType.STRING, 2)
18649 
      oprot.writeString(self.username)
18650 
      oprot.writeFieldEnd()
18651 
    if self.reason is not None:
18652 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18653 
      oprot.writeString(self.reason)
18654 
      oprot.writeFieldEnd()
18655 
    oprot.writeFieldStop()
18656 
    oprot.writeStructEnd()
18657 
 
18658 
  def validate(self):
18659 
    return
18660 
 
18661 
 
18662 
  def __repr__(self):
18663 
    L = ['%s=%r' % (key, value)
18664 
      for key, value in self.__dict__.iteritems()]
18665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18666 
 
18667 
  def __eq__(self, other):
18668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18669 
 
18670 
  def __ne__(self, other):
18671 
    return not (self == other)
18672 
 
18673 
class addAuthorizationLog_result:
18674 
  """
18675 
  Attributes:
18676 
   - success
18677 
   - cex
18678 
  """
18679 
 
18680 
  thrift_spec = (
18681 
    (0, TType.BOOL, 'success', None, None, ), # 0
18682 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18683 
  )
18684 
 
18685 
  def __init__(self, success=None, cex=None,):
18686 
    self.success = success
18687 
    self.cex = cex
18688 
 
18689 
  def read(self, iprot):
18690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18692 
      return
18693 
    iprot.readStructBegin()
18694 
    while True:
18695 
      (fname, ftype, fid) = iprot.readFieldBegin()
18696 
      if ftype == TType.STOP:
18697 
        break
18698 
      if fid == 0:
18699 
        if ftype == TType.BOOL:
18700 
          self.success = iprot.readBool();
18701 
        else:
18702 
          iprot.skip(ftype)
18703 
      elif fid == 1:
18704 
        if ftype == TType.STRUCT:
18705 
          self.cex = CatalogServiceException()
18706 
          self.cex.read(iprot)
18707 
        else:
18708 
          iprot.skip(ftype)
18709 
      else:
18710 
        iprot.skip(ftype)
18711 
      iprot.readFieldEnd()
18712 
    iprot.readStructEnd()
18713 
 
18714 
  def write(self, oprot):
18715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18717 
      return
18718 
    oprot.writeStructBegin('addAuthorizationLog_result')
18719 
    if self.success is not None:
18720 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18721 
      oprot.writeBool(self.success)
18722 
      oprot.writeFieldEnd()
18723 
    if self.cex is not None:
18724 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18725 
      self.cex.write(oprot)
18726 
      oprot.writeFieldEnd()
18727 
    oprot.writeFieldStop()
18728 
    oprot.writeStructEnd()
18729 
 
18730 
  def validate(self):
18731 
    return
18732 
 
18733 
 
18734 
  def __repr__(self):
18735 
    L = ['%s=%r' % (key, value)
18736 
      for key, value in self.__dict__.iteritems()]
18737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18738 
 
18739 
  def __eq__(self, other):
18740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18741 
 
18742 
  def __ne__(self, other):
18743 
    return not (self == other)
18744 
 
18745 
class addupdateVoucherForItem_args:
18746 
  """
18747 
  Attributes:
18748 
   - catalog_item_id
18749 
   - voucherType
18750 
   - voucherAmount
18751 
  """
18752 
 
18753 
  thrift_spec = (
18754 
    None, # 0
18755 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18756 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18757 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
18758 
  )
18759 
 
18760 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
18761 
    self.catalog_item_id = catalog_item_id
18762 
    self.voucherType = voucherType
18763 
    self.voucherAmount = voucherAmount
18764 
 
18765 
  def read(self, iprot):
18766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18768 
      return
18769 
    iprot.readStructBegin()
18770 
    while True:
18771 
      (fname, ftype, fid) = iprot.readFieldBegin()
18772 
      if ftype == TType.STOP:
18773 
        break
18774 
      if fid == 1:
18775 
        if ftype == TType.I64:
18776 
          self.catalog_item_id = iprot.readI64();
18777 
        else:
18778 
          iprot.skip(ftype)
18779 
      elif fid == 2:
18780 
        if ftype == TType.I64:
18781 
          self.voucherType = iprot.readI64();
18782 
        else:
18783 
          iprot.skip(ftype)
18784 
      elif fid == 3:
18785 
        if ftype == TType.I64:
18786 
          self.voucherAmount = iprot.readI64();
18787 
        else:
18788 
          iprot.skip(ftype)
18789 
      else:
18790 
        iprot.skip(ftype)
18791 
      iprot.readFieldEnd()
18792 
    iprot.readStructEnd()
18793 
 
18794 
  def write(self, oprot):
18795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18797 
      return
18798 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
18799 
    if self.catalog_item_id is not None:
18800 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18801 
      oprot.writeI64(self.catalog_item_id)
18802 
      oprot.writeFieldEnd()
18803 
    if self.voucherType is not None:
18804 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18805 
      oprot.writeI64(self.voucherType)
18806 
      oprot.writeFieldEnd()
18807 
    if self.voucherAmount is not None:
18808 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
18809 
      oprot.writeI64(self.voucherAmount)
18810 
      oprot.writeFieldEnd()
18811 
    oprot.writeFieldStop()
18812 
    oprot.writeStructEnd()
18813 
 
18814 
  def validate(self):
18815 
    return
18816 
 
18817 
 
18818 
  def __repr__(self):
18819 
    L = ['%s=%r' % (key, value)
18820 
      for key, value in self.__dict__.iteritems()]
18821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18822 
 
18823 
  def __eq__(self, other):
18824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18825 
 
18826 
  def __ne__(self, other):
18827 
    return not (self == other)
18828 
 
18829 
class addupdateVoucherForItem_result:
18830 
  """
18831 
  Attributes:
18832 
   - success
18833 
   - cex
18834 
  """
18835 
 
18836 
  thrift_spec = (
18837 
    (0, TType.BOOL, 'success', None, None, ), # 0
18838 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18839 
  )
18840 
 
18841 
  def __init__(self, success=None, cex=None,):
18842 
    self.success = success
18843 
    self.cex = cex
18844 
 
18845 
  def read(self, iprot):
18846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18848 
      return
18849 
    iprot.readStructBegin()
18850 
    while True:
18851 
      (fname, ftype, fid) = iprot.readFieldBegin()
18852 
      if ftype == TType.STOP:
18853 
        break
18854 
      if fid == 0:
18855 
        if ftype == TType.BOOL:
18856 
          self.success = iprot.readBool();
18857 
        else:
18858 
          iprot.skip(ftype)
18859 
      elif fid == 1:
18860 
        if ftype == TType.STRUCT:
18861 
          self.cex = CatalogServiceException()
18862 
          self.cex.read(iprot)
18863 
        else:
18864 
          iprot.skip(ftype)
18865 
      else:
18866 
        iprot.skip(ftype)
18867 
      iprot.readFieldEnd()
18868 
    iprot.readStructEnd()
18869 
 
18870 
  def write(self, oprot):
18871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18873 
      return
18874 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
18875 
    if self.success is not None:
18876 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18877 
      oprot.writeBool(self.success)
18878 
      oprot.writeFieldEnd()
18879 
    if self.cex is not None:
18880 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18881 
      self.cex.write(oprot)
18882 
      oprot.writeFieldEnd()
18883 
    oprot.writeFieldStop()
18884 
    oprot.writeStructEnd()
18885 
 
18886 
  def validate(self):
18887 
    return
18888 
 
18889 
 
18890 
  def __repr__(self):
18891 
    L = ['%s=%r' % (key, value)
18892 
      for key, value in self.__dict__.iteritems()]
18893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18894 
 
18895 
  def __eq__(self, other):
18896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18897 
 
18898 
  def __ne__(self, other):
18899 
    return not (self == other)
18900 
 
18901 
class deleteVoucherForItem_args:
18902 
  """
18903 
  Attributes:
18904 
   - catalog_item_id
18905 
   - voucherType
18906 
  """
18907 
 
18908 
  thrift_spec = (
18909 
    None, # 0
18910 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18911 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18912 
  )
18913 
 
18914 
  def __init__(self, catalog_item_id=None, voucherType=None,):
18915 
    self.catalog_item_id = catalog_item_id
18916 
    self.voucherType = voucherType
18917 
 
18918 
  def read(self, iprot):
18919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18921 
      return
18922 
    iprot.readStructBegin()
18923 
    while True:
18924 
      (fname, ftype, fid) = iprot.readFieldBegin()
18925 
      if ftype == TType.STOP:
18926 
        break
18927 
      if fid == 1:
18928 
        if ftype == TType.I64:
18929 
          self.catalog_item_id = iprot.readI64();
18930 
        else:
18931 
          iprot.skip(ftype)
18932 
      elif fid == 2:
18933 
        if ftype == TType.I64:
18934 
          self.voucherType = iprot.readI64();
18935 
        else:
18936 
          iprot.skip(ftype)
18937 
      else:
18938 
        iprot.skip(ftype)
18939 
      iprot.readFieldEnd()
18940 
    iprot.readStructEnd()
18941 
 
18942 
  def write(self, oprot):
18943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18945 
      return
18946 
    oprot.writeStructBegin('deleteVoucherForItem_args')
18947 
    if self.catalog_item_id is not None:
18948 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18949 
      oprot.writeI64(self.catalog_item_id)
18950 
      oprot.writeFieldEnd()
18951 
    if self.voucherType is not None:
18952 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18953 
      oprot.writeI64(self.voucherType)
18954 
      oprot.writeFieldEnd()
18955 
    oprot.writeFieldStop()
18956 
    oprot.writeStructEnd()
18957 
 
18958 
  def validate(self):
18959 
    return
18960 
 
18961 
 
18962 
  def __repr__(self):
18963 
    L = ['%s=%r' % (key, value)
18964 
      for key, value in self.__dict__.iteritems()]
18965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18966 
 
18967 
  def __eq__(self, other):
18968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18969 
 
18970 
  def __ne__(self, other):
18971 
    return not (self == other)
18972 
 
18973 
class deleteVoucherForItem_result:
18974 
  """
18975 
  Attributes:
18976 
   - success
18977 
   - cex
18978 
  """
18979 
 
18980 
  thrift_spec = (
18981 
    (0, TType.BOOL, 'success', None, None, ), # 0
18982 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18983 
  )
18984 
 
18985 
  def __init__(self, success=None, cex=None,):
18986 
    self.success = success
18987 
    self.cex = cex
18988 
 
18989 
  def read(self, iprot):
18990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18992 
      return
18993 
    iprot.readStructBegin()
18994 
    while True:
18995 
      (fname, ftype, fid) = iprot.readFieldBegin()
18996 
      if ftype == TType.STOP:
18997 
        break
18998 
      if fid == 0:
18999 
        if ftype == TType.BOOL:
19000 
          self.success = iprot.readBool();
19001 
        else:
19002 
          iprot.skip(ftype)
19003 
      elif fid == 1:
19004 
        if ftype == TType.STRUCT:
19005 
          self.cex = CatalogServiceException()
19006 
          self.cex.read(iprot)
19007 
        else:
19008 
          iprot.skip(ftype)
19009 
      else:
19010 
        iprot.skip(ftype)
19011 
      iprot.readFieldEnd()
19012 
    iprot.readStructEnd()
19013 
 
19014 
  def write(self, oprot):
19015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19017 
      return
19018 
    oprot.writeStructBegin('deleteVoucherForItem_result')
19019 
    if self.success is not None:
19020 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19021 
      oprot.writeBool(self.success)
19022 
      oprot.writeFieldEnd()
19023 
    if self.cex is not None:
19024 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19025 
      self.cex.write(oprot)
19026 
      oprot.writeFieldEnd()
19027 
    oprot.writeFieldStop()
19028 
    oprot.writeStructEnd()
19029 
 
19030 
  def validate(self):
19031 
    return
19032 
 
19033 
 
19034 
  def __repr__(self):
19035 
    L = ['%s=%r' % (key, value)
19036 
      for key, value in self.__dict__.iteritems()]
19037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19038 
 
19039 
  def __eq__(self, other):
19040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19041 
 
19042 
  def __ne__(self, other):
19043 
    return not (self == other)
19044 
 
19045 
class getVoucherAmount_args:
19046 
  """
19047 
  Attributes:
19048 
   - itemId
19049 
   - voucherType
19050 
  """
19051 
 
19052 
  thrift_spec = (
19053 
    None, # 0
19054 
    (1, TType.I64, 'itemId', None, None, ), # 1
19055 
    (2, TType.I64, 'voucherType', None, None, ), # 2
19056 
  )
19057 
 
19058 
  def __init__(self, itemId=None, voucherType=None,):
19059 
    self.itemId = itemId
19060 
    self.voucherType = voucherType
19061 
 
19062 
  def read(self, iprot):
19063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19065 
      return
19066 
    iprot.readStructBegin()
19067 
    while True:
19068 
      (fname, ftype, fid) = iprot.readFieldBegin()
19069 
      if ftype == TType.STOP:
19070 
        break
19071 
      if fid == 1:
19072 
        if ftype == TType.I64:
19073 
          self.itemId = iprot.readI64();
19074 
        else:
19075 
          iprot.skip(ftype)
19076 
      elif fid == 2:
19077 
        if ftype == TType.I64:
19078 
          self.voucherType = iprot.readI64();
19079 
        else:
19080 
          iprot.skip(ftype)
19081 
      else:
19082 
        iprot.skip(ftype)
19083 
      iprot.readFieldEnd()
19084 
    iprot.readStructEnd()
19085 
 
19086 
  def write(self, oprot):
19087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19089 
      return
19090 
    oprot.writeStructBegin('getVoucherAmount_args')
19091 
    if self.itemId is not None:
19092 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19093 
      oprot.writeI64(self.itemId)
19094 
      oprot.writeFieldEnd()
19095 
    if self.voucherType is not None:
19096 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
19097 
      oprot.writeI64(self.voucherType)
19098 
      oprot.writeFieldEnd()
19099 
    oprot.writeFieldStop()
19100 
    oprot.writeStructEnd()
19101 
 
19102 
  def validate(self):
19103 
    return
19104 
 
19105 
 
19106 
  def __repr__(self):
19107 
    L = ['%s=%r' % (key, value)
19108 
      for key, value in self.__dict__.iteritems()]
19109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19110 
 
19111 
  def __eq__(self, other):
19112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19113 
 
19114 
  def __ne__(self, other):
19115 
    return not (self == other)
19116 
 
19117 
class getVoucherAmount_result:
19118 
  """
19119 
  Attributes:
19120 
   - success
19121 
  """
19122 
 
19123 
  thrift_spec = (
19124 
    (0, TType.I64, 'success', None, None, ), # 0
19125 
  )
19126 
 
19127 
  def __init__(self, success=None,):
19128 
    self.success = success
19129 
 
19130 
  def read(self, iprot):
19131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19133 
      return
19134 
    iprot.readStructBegin()
19135 
    while True:
19136 
      (fname, ftype, fid) = iprot.readFieldBegin()
19137 
      if ftype == TType.STOP:
19138 
        break
19139 
      if fid == 0:
19140 
        if ftype == TType.I64:
19141 
          self.success = iprot.readI64();
19142 
        else:
19143 
          iprot.skip(ftype)
19144 
      else:
19145 
        iprot.skip(ftype)
19146 
      iprot.readFieldEnd()
19147 
    iprot.readStructEnd()
19148 
 
19149 
  def write(self, oprot):
19150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19152 
      return
19153 
    oprot.writeStructBegin('getVoucherAmount_result')
19154 
    if self.success is not None:
19155 
      oprot.writeFieldBegin('success', TType.I64, 0)
19156 
      oprot.writeI64(self.success)
19157 
      oprot.writeFieldEnd()
19158 
    oprot.writeFieldStop()
19159 
    oprot.writeStructEnd()
19160 
 
19161 
  def validate(self):
19162 
    return
19163 
 
19164 
 
19165 
  def __repr__(self):
19166 
    L = ['%s=%r' % (key, value)
19167 
      for key, value in self.__dict__.iteritems()]
19168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19169 
 
19170 
  def __eq__(self, other):
19171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19172 
 
19173 
  def __ne__(self, other):
19174 
    return not (self == other)
19175 
 
19176 
class getAllItemVouchers_args:
19177 
  """
19178 
  Attributes:
19179 
   - itemId
19180 
  """
19181 
 
19182 
  thrift_spec = (
19183 
    None, # 0
19184 
    (1, TType.I64, 'itemId', None, None, ), # 1
19185 
  )
19186 
 
19187 
  def __init__(self, itemId=None,):
19188 
    self.itemId = itemId
19189 
 
19190 
  def read(self, iprot):
19191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19193 
      return
19194 
    iprot.readStructBegin()
19195 
    while True:
19196 
      (fname, ftype, fid) = iprot.readFieldBegin()
19197 
      if ftype == TType.STOP:
19198 
        break
19199 
      if fid == 1:
19200 
        if ftype == TType.I64:
19201 
          self.itemId = iprot.readI64();
19202 
        else:
19203 
          iprot.skip(ftype)
19204 
      else:
19205 
        iprot.skip(ftype)
19206 
      iprot.readFieldEnd()
19207 
    iprot.readStructEnd()
19208 
 
19209 
  def write(self, oprot):
19210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19212 
      return
19213 
    oprot.writeStructBegin('getAllItemVouchers_args')
19214 
    if self.itemId is not None:
19215 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19216 
      oprot.writeI64(self.itemId)
19217 
      oprot.writeFieldEnd()
19218 
    oprot.writeFieldStop()
19219 
    oprot.writeStructEnd()
19220 
 
19221 
  def validate(self):
19222 
    return
19223 
 
19224 
 
19225 
  def __repr__(self):
19226 
    L = ['%s=%r' % (key, value)
19227 
      for key, value in self.__dict__.iteritems()]
19228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19229 
 
19230 
  def __eq__(self, other):
19231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19232 
 
19233 
  def __ne__(self, other):
19234 
    return not (self == other)
19235 
 
19236 
class getAllItemVouchers_result:
19237 
  """
19238 
  Attributes:
19239 
   - success
19240 
  """
19241 
 
19242 
  thrift_spec = (
19243 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
19244 
  )
19245 
 
19246 
  def __init__(self, success=None,):
19247 
    self.success = success
19248 
 
19249 
  def read(self, iprot):
19250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19252 
      return
19253 
    iprot.readStructBegin()
19254 
    while True:
19255 
      (fname, ftype, fid) = iprot.readFieldBegin()
19256 
      if ftype == TType.STOP:
19257 
        break
19258 
      if fid == 0:
19259 
        if ftype == TType.LIST:
19260 
          self.success = []
9155 kshitij.so 19261 
          (_etype363, _size360) = iprot.readListBegin()
19262 
          for _i364 in xrange(_size360):
19263 
            _elem365 = VoucherItemMapping()
19264 
            _elem365.read(iprot)
19265 
            self.success.append(_elem365)
5944 mandeep.dh 19266 
          iprot.readListEnd()
19267 
        else:
19268 
          iprot.skip(ftype)
19269 
      else:
19270 
        iprot.skip(ftype)
19271 
      iprot.readFieldEnd()
19272 
    iprot.readStructEnd()
19273 
 
19274 
  def write(self, oprot):
19275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19277 
      return
19278 
    oprot.writeStructBegin('getAllItemVouchers_result')
19279 
    if self.success is not None:
19280 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19281 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19282 
      for iter366 in self.success:
19283 
        iter366.write(oprot)
5944 mandeep.dh 19284 
      oprot.writeListEnd()
19285 
      oprot.writeFieldEnd()
19286 
    oprot.writeFieldStop()
19287 
    oprot.writeStructEnd()
19288 
 
19289 
  def validate(self):
19290 
    return
19291 
 
19292 
 
19293 
  def __repr__(self):
19294 
    L = ['%s=%r' % (key, value)
19295 
      for key, value in self.__dict__.iteritems()]
19296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19297 
 
19298 
  def __eq__(self, other):
19299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19300 
 
19301 
  def __ne__(self, other):
19302 
    return not (self == other)
19303 
 
19304 
class isValidCatalogItemId_args:
19305 
  """
19306 
  Attributes:
19307 
   - catalog_item_id
19308 
  """
19309 
 
19310 
  thrift_spec = (
19311 
    None, # 0
19312 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
19313 
  )
19314 
 
19315 
  def __init__(self, catalog_item_id=None,):
19316 
    self.catalog_item_id = catalog_item_id
19317 
 
19318 
  def read(self, iprot):
19319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19321 
      return
19322 
    iprot.readStructBegin()
19323 
    while True:
19324 
      (fname, ftype, fid) = iprot.readFieldBegin()
19325 
      if ftype == TType.STOP:
19326 
        break
19327 
      if fid == 1:
19328 
        if ftype == TType.I64:
19329 
          self.catalog_item_id = iprot.readI64();
19330 
        else:
19331 
          iprot.skip(ftype)
19332 
      else:
19333 
        iprot.skip(ftype)
19334 
      iprot.readFieldEnd()
19335 
    iprot.readStructEnd()
19336 
 
19337 
  def write(self, oprot):
19338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19340 
      return
19341 
    oprot.writeStructBegin('isValidCatalogItemId_args')
19342 
    if self.catalog_item_id is not None:
19343 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
19344 
      oprot.writeI64(self.catalog_item_id)
19345 
      oprot.writeFieldEnd()
19346 
    oprot.writeFieldStop()
19347 
    oprot.writeStructEnd()
19348 
 
19349 
  def validate(self):
19350 
    return
19351 
 
19352 
 
19353 
  def __repr__(self):
19354 
    L = ['%s=%r' % (key, value)
19355 
      for key, value in self.__dict__.iteritems()]
19356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19357 
 
19358 
  def __eq__(self, other):
19359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19360 
 
19361 
  def __ne__(self, other):
19362 
    return not (self == other)
19363 
 
19364 
class isValidCatalogItemId_result:
19365 
  """
19366 
  Attributes:
19367 
   - success
19368 
  """
19369 
 
19370 
  thrift_spec = (
19371 
    (0, TType.BOOL, 'success', None, None, ), # 0
19372 
  )
19373 
 
19374 
  def __init__(self, success=None,):
19375 
    self.success = success
19376 
 
19377 
  def read(self, iprot):
19378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19380 
      return
19381 
    iprot.readStructBegin()
19382 
    while True:
19383 
      (fname, ftype, fid) = iprot.readFieldBegin()
19384 
      if ftype == TType.STOP:
19385 
        break
19386 
      if fid == 0:
19387 
        if ftype == TType.BOOL:
19388 
          self.success = iprot.readBool();
19389 
        else:
19390 
          iprot.skip(ftype)
19391 
      else:
19392 
        iprot.skip(ftype)
19393 
      iprot.readFieldEnd()
19394 
    iprot.readStructEnd()
19395 
 
19396 
  def write(self, oprot):
19397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19399 
      return
19400 
    oprot.writeStructBegin('isValidCatalogItemId_result')
19401 
    if self.success is not None:
19402 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19403 
      oprot.writeBool(self.success)
19404 
      oprot.writeFieldEnd()
19405 
    oprot.writeFieldStop()
19406 
    oprot.writeStructEnd()
19407 
 
19408 
  def validate(self):
19409 
    return
19410 
 
19411 
 
19412 
  def __repr__(self):
19413 
    L = ['%s=%r' % (key, value)
19414 
      for key, value in self.__dict__.iteritems()]
19415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19416 
 
19417 
  def __eq__(self, other):
19418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19419 
 
19420 
  def __ne__(self, other):
19421 
    return not (self == other)
6039 amit.gupta 19422 
 
19423 
class getVatPercentageForItem_args:
19424 
  """
19425 
  Attributes:
19426 
   - itemId
7330 amit.gupta 19427 
   - stateId
6039 amit.gupta 19428 
   - price
19429 
  """
19430 
 
19431 
  thrift_spec = (
19432 
    None, # 0
19433 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 19434 
    (2, TType.I64, 'stateId', None, None, ), # 2
19435 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 19436 
  )
19437 
 
7330 amit.gupta 19438 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 19439 
    self.itemId = itemId
7330 amit.gupta 19440 
    self.stateId = stateId
6039 amit.gupta 19441 
    self.price = price
19442 
 
19443 
  def read(self, iprot):
19444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19446 
      return
19447 
    iprot.readStructBegin()
19448 
    while True:
19449 
      (fname, ftype, fid) = iprot.readFieldBegin()
19450 
      if ftype == TType.STOP:
19451 
        break
19452 
      if fid == 1:
19453 
        if ftype == TType.I64:
19454 
          self.itemId = iprot.readI64();
19455 
        else:
19456 
          iprot.skip(ftype)
19457 
      elif fid == 2:
7330 amit.gupta 19458 
        if ftype == TType.I64:
19459 
          self.stateId = iprot.readI64();
19460 
        else:
19461 
          iprot.skip(ftype)
19462 
      elif fid == 3:
6039 amit.gupta 19463 
        if ftype == TType.DOUBLE:
19464 
          self.price = iprot.readDouble();
19465 
        else:
19466 
          iprot.skip(ftype)
19467 
      else:
19468 
        iprot.skip(ftype)
19469 
      iprot.readFieldEnd()
19470 
    iprot.readStructEnd()
19471 
 
19472 
  def write(self, oprot):
19473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19475 
      return
19476 
    oprot.writeStructBegin('getVatPercentageForItem_args')
19477 
    if self.itemId is not None:
19478 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19479 
      oprot.writeI64(self.itemId)
19480 
      oprot.writeFieldEnd()
7330 amit.gupta 19481 
    if self.stateId is not None:
19482 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
19483 
      oprot.writeI64(self.stateId)
19484 
      oprot.writeFieldEnd()
6039 amit.gupta 19485 
    if self.price is not None:
7330 amit.gupta 19486 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 19487 
      oprot.writeDouble(self.price)
19488 
      oprot.writeFieldEnd()
19489 
    oprot.writeFieldStop()
19490 
    oprot.writeStructEnd()
19491 
 
19492 
  def validate(self):
19493 
    return
19494 
 
19495 
 
19496 
  def __repr__(self):
19497 
    L = ['%s=%r' % (key, value)
19498 
      for key, value in self.__dict__.iteritems()]
19499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19500 
 
19501 
  def __eq__(self, other):
19502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19503 
 
19504 
  def __ne__(self, other):
19505 
    return not (self == other)
19506 
 
19507 
class getVatPercentageForItem_result:
19508 
  """
19509 
  Attributes:
19510 
   - success
7340 amit.gupta 19511 
   - cex
6039 amit.gupta 19512 
  """
19513 
 
19514 
  thrift_spec = (
19515 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 19516 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 19517 
  )
19518 
 
7340 amit.gupta 19519 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 19520 
    self.success = success
7340 amit.gupta 19521 
    self.cex = cex
6039 amit.gupta 19522 
 
19523 
  def read(self, iprot):
19524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19526 
      return
19527 
    iprot.readStructBegin()
19528 
    while True:
19529 
      (fname, ftype, fid) = iprot.readFieldBegin()
19530 
      if ftype == TType.STOP:
19531 
        break
19532 
      if fid == 0:
19533 
        if ftype == TType.DOUBLE:
19534 
          self.success = iprot.readDouble();
19535 
        else:
19536 
          iprot.skip(ftype)
7340 amit.gupta 19537 
      elif fid == 1:
19538 
        if ftype == TType.STRUCT:
19539 
          self.cex = CatalogServiceException()
19540 
          self.cex.read(iprot)
19541 
        else:
19542 
          iprot.skip(ftype)
6039 amit.gupta 19543 
      else:
19544 
        iprot.skip(ftype)
19545 
      iprot.readFieldEnd()
19546 
    iprot.readStructEnd()
19547 
 
19548 
  def write(self, oprot):
19549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19551 
      return
19552 
    oprot.writeStructBegin('getVatPercentageForItem_result')
19553 
    if self.success is not None:
19554 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
19555 
      oprot.writeDouble(self.success)
19556 
      oprot.writeFieldEnd()
7340 amit.gupta 19557 
    if self.cex is not None:
19558 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19559 
      self.cex.write(oprot)
19560 
      oprot.writeFieldEnd()
6039 amit.gupta 19561 
    oprot.writeFieldStop()
19562 
    oprot.writeStructEnd()
19563 
 
19564 
  def validate(self):
19565 
    return
19566 
 
19567 
 
19568 
  def __repr__(self):
19569 
    L = ['%s=%r' % (key, value)
19570 
      for key, value in self.__dict__.iteritems()]
19571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19572 
 
19573 
  def __eq__(self, other):
19574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19575 
 
19576 
  def __ne__(self, other):
19577 
    return not (self == other)
19578 
 
19579 
class getVatAmountForItem_args:
19580 
  """
19581 
  Attributes:
19582 
   - itemId
19583 
   - price
19584 
  """
19585 
 
19586 
  thrift_spec = (
19587 
    None, # 0
19588 
    (1, TType.I64, 'itemId', None, None, ), # 1
19589 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
19590 
  )
19591 
 
19592 
  def __init__(self, itemId=None, price=None,):
19593 
    self.itemId = itemId
19594 
    self.price = price
19595 
 
19596 
  def read(self, iprot):
19597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19599 
      return
19600 
    iprot.readStructBegin()
19601 
    while True:
19602 
      (fname, ftype, fid) = iprot.readFieldBegin()
19603 
      if ftype == TType.STOP:
19604 
        break
19605 
      if fid == 1:
19606 
        if ftype == TType.I64:
19607 
          self.itemId = iprot.readI64();
19608 
        else:
19609 
          iprot.skip(ftype)
19610 
      elif fid == 2:
19611 
        if ftype == TType.DOUBLE:
19612 
          self.price = iprot.readDouble();
19613 
        else:
19614 
          iprot.skip(ftype)
19615 
      else:
19616 
        iprot.skip(ftype)
19617 
      iprot.readFieldEnd()
19618 
    iprot.readStructEnd()
19619 
 
19620 
  def write(self, oprot):
19621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19623 
      return
19624 
    oprot.writeStructBegin('getVatAmountForItem_args')
19625 
    if self.itemId is not None:
19626 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19627 
      oprot.writeI64(self.itemId)
19628 
      oprot.writeFieldEnd()
19629 
    if self.price is not None:
19630 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
19631 
      oprot.writeDouble(self.price)
19632 
      oprot.writeFieldEnd()
19633 
    oprot.writeFieldStop()
19634 
    oprot.writeStructEnd()
19635 
 
19636 
  def validate(self):
19637 
    return
19638 
 
19639 
 
19640 
  def __repr__(self):
19641 
    L = ['%s=%r' % (key, value)
19642 
      for key, value in self.__dict__.iteritems()]
19643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19644 
 
19645 
  def __eq__(self, other):
19646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19647 
 
19648 
  def __ne__(self, other):
19649 
    return not (self == other)
19650 
 
19651 
class getVatAmountForItem_result:
19652 
  """
19653 
  Attributes:
19654 
   - success
19655 
  """
19656 
 
19657 
  thrift_spec = (
19658 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
19659 
  )
19660 
 
19661 
  def __init__(self, success=None,):
19662 
    self.success = success
19663 
 
19664 
  def read(self, iprot):
19665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19667 
      return
19668 
    iprot.readStructBegin()
19669 
    while True:
19670 
      (fname, ftype, fid) = iprot.readFieldBegin()
19671 
      if ftype == TType.STOP:
19672 
        break
19673 
      if fid == 0:
19674 
        if ftype == TType.DOUBLE:
19675 
          self.success = iprot.readDouble();
19676 
        else:
19677 
          iprot.skip(ftype)
19678 
      else:
19679 
        iprot.skip(ftype)
19680 
      iprot.readFieldEnd()
19681 
    iprot.readStructEnd()
19682 
 
19683 
  def write(self, oprot):
19684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19686 
      return
19687 
    oprot.writeStructBegin('getVatAmountForItem_result')
19688 
    if self.success is not None:
19689 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
19690 
      oprot.writeDouble(self.success)
19691 
      oprot.writeFieldEnd()
19692 
    oprot.writeFieldStop()
19693 
    oprot.writeStructEnd()
19694 
 
19695 
  def validate(self):
19696 
    return
19697 
 
19698 
 
19699 
  def __repr__(self):
19700 
    L = ['%s=%r' % (key, value)
19701 
      for key, value in self.__dict__.iteritems()]
19702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19703 
 
19704 
  def __eq__(self, other):
19705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19706 
 
19707 
  def __ne__(self, other):
19708 
    return not (self == other)
6531 vikram.rag 19709 
 
19710 
class getAllIgnoredInventoryUpdateItemsList_args:
19711 
  """
19712 
  Attributes:
19713 
   - offset
19714 
   - limit
19715 
  """
19716 
 
19717 
  thrift_spec = (
19718 
    None, # 0
19719 
    (1, TType.I32, 'offset', None, None, ), # 1
19720 
    (2, TType.I32, 'limit', None, None, ), # 2
19721 
  )
19722 
 
19723 
  def __init__(self, offset=None, limit=None,):
19724 
    self.offset = offset
19725 
    self.limit = limit
19726 
 
19727 
  def read(self, iprot):
19728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19730 
      return
19731 
    iprot.readStructBegin()
19732 
    while True:
19733 
      (fname, ftype, fid) = iprot.readFieldBegin()
19734 
      if ftype == TType.STOP:
19735 
        break
19736 
      if fid == 1:
19737 
        if ftype == TType.I32:
19738 
          self.offset = iprot.readI32();
19739 
        else:
19740 
          iprot.skip(ftype)
19741 
      elif fid == 2:
19742 
        if ftype == TType.I32:
19743 
          self.limit = iprot.readI32();
19744 
        else:
19745 
          iprot.skip(ftype)
19746 
      else:
19747 
        iprot.skip(ftype)
19748 
      iprot.readFieldEnd()
19749 
    iprot.readStructEnd()
19750 
 
19751 
  def write(self, oprot):
19752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19754 
      return
19755 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
19756 
    if self.offset is not None:
19757 
      oprot.writeFieldBegin('offset', TType.I32, 1)
19758 
      oprot.writeI32(self.offset)
19759 
      oprot.writeFieldEnd()
19760 
    if self.limit is not None:
19761 
      oprot.writeFieldBegin('limit', TType.I32, 2)
19762 
      oprot.writeI32(self.limit)
19763 
      oprot.writeFieldEnd()
19764 
    oprot.writeFieldStop()
19765 
    oprot.writeStructEnd()
19766 
 
19767 
  def validate(self):
19768 
    return
19769 
 
19770 
 
19771 
  def __repr__(self):
19772 
    L = ['%s=%r' % (key, value)
19773 
      for key, value in self.__dict__.iteritems()]
19774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19775 
 
19776 
  def __eq__(self, other):
19777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19778 
 
19779 
  def __ne__(self, other):
19780 
    return not (self == other)
19781 
 
19782 
class getAllIgnoredInventoryUpdateItemsList_result:
19783 
  """
19784 
  Attributes:
19785 
   - success
19786 
  """
19787 
 
19788 
  thrift_spec = (
19789 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19790 
  )
19791 
 
19792 
  def __init__(self, success=None,):
19793 
    self.success = success
19794 
 
19795 
  def read(self, iprot):
19796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19798 
      return
19799 
    iprot.readStructBegin()
19800 
    while True:
19801 
      (fname, ftype, fid) = iprot.readFieldBegin()
19802 
      if ftype == TType.STOP:
19803 
        break
19804 
      if fid == 0:
19805 
        if ftype == TType.LIST:
19806 
          self.success = []
9155 kshitij.so 19807 
          (_etype370, _size367) = iprot.readListBegin()
19808 
          for _i371 in xrange(_size367):
19809 
            _elem372 = Item()
19810 
            _elem372.read(iprot)
19811 
            self.success.append(_elem372)
6531 vikram.rag 19812 
          iprot.readListEnd()
19813 
        else:
19814 
          iprot.skip(ftype)
19815 
      else:
19816 
        iprot.skip(ftype)
19817 
      iprot.readFieldEnd()
19818 
    iprot.readStructEnd()
19819 
 
19820 
  def write(self, oprot):
19821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19823 
      return
19824 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
19825 
    if self.success is not None:
19826 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19827 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19828 
      for iter373 in self.success:
19829 
        iter373.write(oprot)
6531 vikram.rag 19830 
      oprot.writeListEnd()
19831 
      oprot.writeFieldEnd()
19832 
    oprot.writeFieldStop()
19833 
    oprot.writeStructEnd()
19834 
 
19835 
  def validate(self):
19836 
    return
19837 
 
19838 
 
19839 
  def __repr__(self):
19840 
    L = ['%s=%r' % (key, value)
19841 
      for key, value in self.__dict__.iteritems()]
19842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19843 
 
19844 
  def __eq__(self, other):
19845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19846 
 
19847 
  def __ne__(self, other):
19848 
    return not (self == other)
6805 anupam.sin 19849 
 
6821 amar.kumar 19850 
class getAllAliveItems_args:
19851 
 
19852 
  thrift_spec = (
19853 
  )
19854 
 
19855 
  def read(self, iprot):
19856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19858 
      return
19859 
    iprot.readStructBegin()
19860 
    while True:
19861 
      (fname, ftype, fid) = iprot.readFieldBegin()
19862 
      if ftype == TType.STOP:
19863 
        break
19864 
      else:
19865 
        iprot.skip(ftype)
19866 
      iprot.readFieldEnd()
19867 
    iprot.readStructEnd()
19868 
 
19869 
  def write(self, oprot):
19870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19872 
      return
19873 
    oprot.writeStructBegin('getAllAliveItems_args')
19874 
    oprot.writeFieldStop()
19875 
    oprot.writeStructEnd()
19876 
 
19877 
  def validate(self):
19878 
    return
19879 
 
19880 
 
19881 
  def __repr__(self):
19882 
    L = ['%s=%r' % (key, value)
19883 
      for key, value in self.__dict__.iteritems()]
19884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19885 
 
19886 
  def __eq__(self, other):
19887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19888 
 
19889 
  def __ne__(self, other):
19890 
    return not (self == other)
19891 
 
19892 
class getAllAliveItems_result:
19893 
  """
19894 
  Attributes:
19895 
   - success
19896 
  """
19897 
 
19898 
  thrift_spec = (
19899 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19900 
  )
19901 
 
19902 
  def __init__(self, success=None,):
19903 
    self.success = success
19904 
 
19905 
  def read(self, iprot):
19906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19908 
      return
19909 
    iprot.readStructBegin()
19910 
    while True:
19911 
      (fname, ftype, fid) = iprot.readFieldBegin()
19912 
      if ftype == TType.STOP:
19913 
        break
19914 
      if fid == 0:
19915 
        if ftype == TType.LIST:
19916 
          self.success = []
9155 kshitij.so 19917 
          (_etype377, _size374) = iprot.readListBegin()
19918 
          for _i378 in xrange(_size374):
19919 
            _elem379 = Item()
19920 
            _elem379.read(iprot)
19921 
            self.success.append(_elem379)
6821 amar.kumar 19922 
          iprot.readListEnd()
19923 
        else:
19924 
          iprot.skip(ftype)
19925 
      else:
19926 
        iprot.skip(ftype)
19927 
      iprot.readFieldEnd()
19928 
    iprot.readStructEnd()
19929 
 
19930 
  def write(self, oprot):
19931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19933 
      return
19934 
    oprot.writeStructBegin('getAllAliveItems_result')
19935 
    if self.success is not None:
19936 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19937 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19938 
      for iter380 in self.success:
19939 
        iter380.write(oprot)
6821 amar.kumar 19940 
      oprot.writeListEnd()
19941 
      oprot.writeFieldEnd()
19942 
    oprot.writeFieldStop()
19943 
    oprot.writeStructEnd()
19944 
 
19945 
  def validate(self):
19946 
    return
19947 
 
19948 
 
19949 
  def __repr__(self):
19950 
    L = ['%s=%r' % (key, value)
19951 
      for key, value in self.__dict__.iteritems()]
19952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19953 
 
19954 
  def __eq__(self, other):
19955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19956 
 
19957 
  def __ne__(self, other):
19958 
    return not (self == other)
19959 
 
6805 anupam.sin 19960 
class getInsuranceAmount_args:
19961 
  """
19962 
  Attributes:
19963 
   - itemId
6921 anupam.sin 19964 
   - price
6805 anupam.sin 19965 
   - insurerId
19966 
   - quantity
19967 
  """
19968 
 
19969 
  thrift_spec = (
19970 
    None, # 0
19971 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 19972 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
19973 
    (3, TType.I64, 'insurerId', None, None, ), # 3
19974 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 19975 
  )
19976 
 
6921 anupam.sin 19977 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 19978 
    self.itemId = itemId
6921 anupam.sin 19979 
    self.price = price
6805 anupam.sin 19980 
    self.insurerId = insurerId
19981 
    self.quantity = quantity
19982 
 
19983 
  def read(self, iprot):
19984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19986 
      return
19987 
    iprot.readStructBegin()
19988 
    while True:
19989 
      (fname, ftype, fid) = iprot.readFieldBegin()
19990 
      if ftype == TType.STOP:
19991 
        break
19992 
      if fid == 1:
19993 
        if ftype == TType.I64:
19994 
          self.itemId = iprot.readI64();
19995 
        else:
19996 
          iprot.skip(ftype)
19997 
      elif fid == 2:
6921 anupam.sin 19998 
        if ftype == TType.DOUBLE:
19999 
          self.price = iprot.readDouble();
20000 
        else:
20001 
          iprot.skip(ftype)
20002 
      elif fid == 3:
6805 anupam.sin 20003 
        if ftype == TType.I64:
20004 
          self.insurerId = iprot.readI64();
20005 
        else:
20006 
          iprot.skip(ftype)
6921 anupam.sin 20007 
      elif fid == 4:
6805 anupam.sin 20008 
        if ftype == TType.I64:
20009 
          self.quantity = iprot.readI64();
20010 
        else:
20011 
          iprot.skip(ftype)
20012 
      else:
20013 
        iprot.skip(ftype)
20014 
      iprot.readFieldEnd()
20015 
    iprot.readStructEnd()
20016 
 
20017 
  def write(self, oprot):
20018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20020 
      return
20021 
    oprot.writeStructBegin('getInsuranceAmount_args')
20022 
    if self.itemId is not None:
20023 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20024 
      oprot.writeI64(self.itemId)
20025 
      oprot.writeFieldEnd()
6921 anupam.sin 20026 
    if self.price is not None:
20027 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
20028 
      oprot.writeDouble(self.price)
20029 
      oprot.writeFieldEnd()
6805 anupam.sin 20030 
    if self.insurerId is not None:
6921 anupam.sin 20031 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 20032 
      oprot.writeI64(self.insurerId)
20033 
      oprot.writeFieldEnd()
20034 
    if self.quantity is not None:
6921 anupam.sin 20035 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 20036 
      oprot.writeI64(self.quantity)
20037 
      oprot.writeFieldEnd()
20038 
    oprot.writeFieldStop()
20039 
    oprot.writeStructEnd()
20040 
 
20041 
  def validate(self):
20042 
    return
20043 
 
20044 
 
20045 
  def __repr__(self):
20046 
    L = ['%s=%r' % (key, value)
20047 
      for key, value in self.__dict__.iteritems()]
20048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20049 
 
20050 
  def __eq__(self, other):
20051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20052 
 
20053 
  def __ne__(self, other):
20054 
    return not (self == other)
20055 
 
20056 
class getInsuranceAmount_result:
20057 
  """
20058 
  Attributes:
20059 
   - success
20060 
  """
20061 
 
20062 
  thrift_spec = (
20063 
    (0, TType.I64, 'success', None, None, ), # 0
20064 
  )
20065 
 
20066 
  def __init__(self, success=None,):
20067 
    self.success = success
20068 
 
20069 
  def read(self, iprot):
20070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20072 
      return
20073 
    iprot.readStructBegin()
20074 
    while True:
20075 
      (fname, ftype, fid) = iprot.readFieldBegin()
20076 
      if ftype == TType.STOP:
20077 
        break
20078 
      if fid == 0:
20079 
        if ftype == TType.I64:
20080 
          self.success = iprot.readI64();
20081 
        else:
20082 
          iprot.skip(ftype)
20083 
      else:
20084 
        iprot.skip(ftype)
20085 
      iprot.readFieldEnd()
20086 
    iprot.readStructEnd()
20087 
 
20088 
  def write(self, oprot):
20089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20091 
      return
20092 
    oprot.writeStructBegin('getInsuranceAmount_result')
20093 
    if self.success is not None:
20094 
      oprot.writeFieldBegin('success', TType.I64, 0)
20095 
      oprot.writeI64(self.success)
20096 
      oprot.writeFieldEnd()
20097 
    oprot.writeFieldStop()
20098 
    oprot.writeStructEnd()
20099 
 
20100 
  def validate(self):
20101 
    return
20102 
 
20103 
 
20104 
  def __repr__(self):
20105 
    L = ['%s=%r' % (key, value)
20106 
      for key, value in self.__dict__.iteritems()]
20107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20108 
 
20109 
  def __eq__(self, other):
20110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20111 
 
20112 
  def __ne__(self, other):
20113 
    return not (self == other)
20114 
 
20115 
class getInsurer_args:
20116 
  """
20117 
  Attributes:
20118 
   - insurerId
20119 
  """
20120 
 
20121 
  thrift_spec = (
20122 
    None, # 0
20123 
    (1, TType.I64, 'insurerId', None, None, ), # 1
20124 
  )
20125 
 
20126 
  def __init__(self, insurerId=None,):
20127 
    self.insurerId = insurerId
20128 
 
20129 
  def read(self, iprot):
20130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20132 
      return
20133 
    iprot.readStructBegin()
20134 
    while True:
20135 
      (fname, ftype, fid) = iprot.readFieldBegin()
20136 
      if ftype == TType.STOP:
20137 
        break
20138 
      if fid == 1:
20139 
        if ftype == TType.I64:
20140 
          self.insurerId = iprot.readI64();
20141 
        else:
20142 
          iprot.skip(ftype)
20143 
      else:
20144 
        iprot.skip(ftype)
20145 
      iprot.readFieldEnd()
20146 
    iprot.readStructEnd()
20147 
 
20148 
  def write(self, oprot):
20149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20151 
      return
20152 
    oprot.writeStructBegin('getInsurer_args')
20153 
    if self.insurerId is not None:
20154 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
20155 
      oprot.writeI64(self.insurerId)
20156 
      oprot.writeFieldEnd()
20157 
    oprot.writeFieldStop()
20158 
    oprot.writeStructEnd()
20159 
 
20160 
  def validate(self):
20161 
    return
20162 
 
20163 
 
20164 
  def __repr__(self):
20165 
    L = ['%s=%r' % (key, value)
20166 
      for key, value in self.__dict__.iteritems()]
20167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20168 
 
20169 
  def __eq__(self, other):
20170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20171 
 
20172 
  def __ne__(self, other):
20173 
    return not (self == other)
20174 
 
20175 
class getInsurer_result:
20176 
  """
20177 
  Attributes:
20178 
   - success
20179 
  """
20180 
 
20181 
  thrift_spec = (
20182 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
20183 
  )
20184 
 
20185 
  def __init__(self, success=None,):
20186 
    self.success = success
20187 
 
20188 
  def read(self, iprot):
20189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20191 
      return
20192 
    iprot.readStructBegin()
20193 
    while True:
20194 
      (fname, ftype, fid) = iprot.readFieldBegin()
20195 
      if ftype == TType.STOP:
20196 
        break
20197 
      if fid == 0:
20198 
        if ftype == TType.STRUCT:
20199 
          self.success = Insurer()
20200 
          self.success.read(iprot)
20201 
        else:
20202 
          iprot.skip(ftype)
20203 
      else:
20204 
        iprot.skip(ftype)
20205 
      iprot.readFieldEnd()
20206 
    iprot.readStructEnd()
20207 
 
20208 
  def write(self, oprot):
20209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20211 
      return
20212 
    oprot.writeStructBegin('getInsurer_result')
20213 
    if self.success is not None:
20214 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20215 
      self.success.write(oprot)
20216 
      oprot.writeFieldEnd()
20217 
    oprot.writeFieldStop()
20218 
    oprot.writeStructEnd()
20219 
 
20220 
  def validate(self):
20221 
    return
20222 
 
20223 
 
20224 
  def __repr__(self):
20225 
    L = ['%s=%r' % (key, value)
20226 
      for key, value in self.__dict__.iteritems()]
20227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20228 
 
20229 
  def __eq__(self, other):
20230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20231 
 
20232 
  def __ne__(self, other):
20233 
    return not (self == other)
6838 vikram.rag 20234 
 
20235 
class getAllInsurers_args:
20236 
 
20237 
  thrift_spec = (
20238 
  )
20239 
 
20240 
  def read(self, iprot):
20241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20243 
      return
20244 
    iprot.readStructBegin()
20245 
    while True:
20246 
      (fname, ftype, fid) = iprot.readFieldBegin()
20247 
      if ftype == TType.STOP:
20248 
        break
20249 
      else:
20250 
        iprot.skip(ftype)
20251 
      iprot.readFieldEnd()
20252 
    iprot.readStructEnd()
20253 
 
20254 
  def write(self, oprot):
20255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20257 
      return
20258 
    oprot.writeStructBegin('getAllInsurers_args')
20259 
    oprot.writeFieldStop()
20260 
    oprot.writeStructEnd()
20261 
 
20262 
  def validate(self):
20263 
    return
20264 
 
20265 
 
20266 
  def __repr__(self):
20267 
    L = ['%s=%r' % (key, value)
20268 
      for key, value in self.__dict__.iteritems()]
20269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20270 
 
20271 
  def __eq__(self, other):
20272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20273 
 
20274 
  def __ne__(self, other):
20275 
    return not (self == other)
20276 
 
20277 
class getAllInsurers_result:
20278 
  """
20279 
  Attributes:
20280 
   - success
20281 
  """
20282 
 
20283 
  thrift_spec = (
20284 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
20285 
  )
20286 
 
20287 
  def __init__(self, success=None,):
20288 
    self.success = success
20289 
 
20290 
  def read(self, iprot):
20291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20293 
      return
20294 
    iprot.readStructBegin()
20295 
    while True:
20296 
      (fname, ftype, fid) = iprot.readFieldBegin()
20297 
      if ftype == TType.STOP:
20298 
        break
20299 
      if fid == 0:
20300 
        if ftype == TType.LIST:
20301 
          self.success = []
9155 kshitij.so 20302 
          (_etype384, _size381) = iprot.readListBegin()
20303 
          for _i385 in xrange(_size381):
20304 
            _elem386 = Insurer()
20305 
            _elem386.read(iprot)
20306 
            self.success.append(_elem386)
6838 vikram.rag 20307 
          iprot.readListEnd()
20308 
        else:
20309 
          iprot.skip(ftype)
20310 
      else:
20311 
        iprot.skip(ftype)
20312 
      iprot.readFieldEnd()
20313 
    iprot.readStructEnd()
20314 
 
20315 
  def write(self, oprot):
20316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20318 
      return
20319 
    oprot.writeStructBegin('getAllInsurers_result')
20320 
    if self.success is not None:
20321 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20322 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20323 
      for iter387 in self.success:
20324 
        iter387.write(oprot)
6838 vikram.rag 20325 
      oprot.writeListEnd()
20326 
      oprot.writeFieldEnd()
20327 
    oprot.writeFieldStop()
20328 
    oprot.writeStructEnd()
20329 
 
20330 
  def validate(self):
20331 
    return
20332 
 
20333 
 
20334 
  def __repr__(self):
20335 
    L = ['%s=%r' % (key, value)
20336 
      for key, value in self.__dict__.iteritems()]
20337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20338 
 
20339 
  def __eq__(self, other):
20340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20341 
 
20342 
  def __ne__(self, other):
20343 
    return not (self == other)
6962 rajveer 20344 
 
20345 
class updateInsuranceDeclaredAmount_args:
20346 
  """
20347 
  Attributes:
20348 
   - insurerId
20349 
   - amount
20350 
  """
20351 
 
20352 
  thrift_spec = (
20353 
    None, # 0
20354 
    (1, TType.I64, 'insurerId', None, None, ), # 1
20355 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
20356 
  )
20357 
 
20358 
  def __init__(self, insurerId=None, amount=None,):
20359 
    self.insurerId = insurerId
20360 
    self.amount = amount
20361 
 
20362 
  def read(self, iprot):
20363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20365 
      return
20366 
    iprot.readStructBegin()
20367 
    while True:
20368 
      (fname, ftype, fid) = iprot.readFieldBegin()
20369 
      if ftype == TType.STOP:
20370 
        break
20371 
      if fid == 1:
20372 
        if ftype == TType.I64:
20373 
          self.insurerId = iprot.readI64();
20374 
        else:
20375 
          iprot.skip(ftype)
20376 
      elif fid == 2:
20377 
        if ftype == TType.DOUBLE:
20378 
          self.amount = iprot.readDouble();
20379 
        else:
20380 
          iprot.skip(ftype)
20381 
      else:
20382 
        iprot.skip(ftype)
20383 
      iprot.readFieldEnd()
20384 
    iprot.readStructEnd()
20385 
 
20386 
  def write(self, oprot):
20387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20389 
      return
20390 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
20391 
    if self.insurerId is not None:
20392 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
20393 
      oprot.writeI64(self.insurerId)
20394 
      oprot.writeFieldEnd()
20395 
    if self.amount is not None:
20396 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
20397 
      oprot.writeDouble(self.amount)
20398 
      oprot.writeFieldEnd()
20399 
    oprot.writeFieldStop()
20400 
    oprot.writeStructEnd()
20401 
 
20402 
  def validate(self):
20403 
    return
20404 
 
20405 
 
20406 
  def __repr__(self):
20407 
    L = ['%s=%r' % (key, value)
20408 
      for key, value in self.__dict__.iteritems()]
20409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20410 
 
20411 
  def __eq__(self, other):
20412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20413 
 
20414 
  def __ne__(self, other):
20415 
    return not (self == other)
20416 
 
20417 
class updateInsuranceDeclaredAmount_result:
20418 
 
20419 
  thrift_spec = (
20420 
  )
20421 
 
20422 
  def read(self, iprot):
20423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20425 
      return
20426 
    iprot.readStructBegin()
20427 
    while True:
20428 
      (fname, ftype, fid) = iprot.readFieldBegin()
20429 
      if ftype == TType.STOP:
20430 
        break
20431 
      else:
20432 
        iprot.skip(ftype)
20433 
      iprot.readFieldEnd()
20434 
    iprot.readStructEnd()
20435 
 
20436 
  def write(self, oprot):
20437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20439 
      return
20440 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
20441 
    oprot.writeFieldStop()
20442 
    oprot.writeStructEnd()
20443 
 
20444 
  def validate(self):
20445 
    return
20446 
 
20447 
 
20448 
  def __repr__(self):
20449 
    L = ['%s=%r' % (key, value)
20450 
      for key, value in self.__dict__.iteritems()]
20451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20452 
 
20453 
  def __eq__(self, other):
20454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20455 
 
20456 
  def __ne__(self, other):
20457 
    return not (self == other)
7190 amar.kumar 20458 
 
20459 
class getFreebieForItem_args:
20460 
  """
20461 
  Attributes:
20462 
   - itemId
20463 
  """
20464 
 
20465 
  thrift_spec = (
20466 
    None, # 0
20467 
    (1, TType.I64, 'itemId', None, None, ), # 1
20468 
  )
20469 
 
20470 
  def __init__(self, itemId=None,):
20471 
    self.itemId = itemId
20472 
 
20473 
  def read(self, iprot):
20474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20476 
      return
20477 
    iprot.readStructBegin()
20478 
    while True:
20479 
      (fname, ftype, fid) = iprot.readFieldBegin()
20480 
      if ftype == TType.STOP:
20481 
        break
20482 
      if fid == 1:
20483 
        if ftype == TType.I64:
20484 
          self.itemId = iprot.readI64();
20485 
        else:
20486 
          iprot.skip(ftype)
20487 
      else:
20488 
        iprot.skip(ftype)
20489 
      iprot.readFieldEnd()
20490 
    iprot.readStructEnd()
20491 
 
20492 
  def write(self, oprot):
20493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20495 
      return
20496 
    oprot.writeStructBegin('getFreebieForItem_args')
20497 
    if self.itemId is not None:
20498 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20499 
      oprot.writeI64(self.itemId)
20500 
      oprot.writeFieldEnd()
20501 
    oprot.writeFieldStop()
20502 
    oprot.writeStructEnd()
20503 
 
20504 
  def validate(self):
20505 
    return
20506 
 
20507 
 
20508 
  def __repr__(self):
20509 
    L = ['%s=%r' % (key, value)
20510 
      for key, value in self.__dict__.iteritems()]
20511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20512 
 
20513 
  def __eq__(self, other):
20514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20515 
 
20516 
  def __ne__(self, other):
20517 
    return not (self == other)
20518 
 
20519 
class getFreebieForItem_result:
20520 
  """
20521 
  Attributes:
20522 
   - success
20523 
  """
20524 
 
20525 
  thrift_spec = (
20526 
    (0, TType.I64, 'success', None, None, ), # 0
20527 
  )
20528 
 
20529 
  def __init__(self, success=None,):
20530 
    self.success = success
20531 
 
20532 
  def read(self, iprot):
20533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20535 
      return
20536 
    iprot.readStructBegin()
20537 
    while True:
20538 
      (fname, ftype, fid) = iprot.readFieldBegin()
20539 
      if ftype == TType.STOP:
20540 
        break
20541 
      if fid == 0:
20542 
        if ftype == TType.I64:
20543 
          self.success = iprot.readI64();
20544 
        else:
20545 
          iprot.skip(ftype)
20546 
      else:
20547 
        iprot.skip(ftype)
20548 
      iprot.readFieldEnd()
20549 
    iprot.readStructEnd()
20550 
 
20551 
  def write(self, oprot):
20552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20554 
      return
20555 
    oprot.writeStructBegin('getFreebieForItem_result')
20556 
    if self.success is not None:
20557 
      oprot.writeFieldBegin('success', TType.I64, 0)
20558 
      oprot.writeI64(self.success)
20559 
      oprot.writeFieldEnd()
20560 
    oprot.writeFieldStop()
20561 
    oprot.writeStructEnd()
20562 
 
20563 
  def validate(self):
20564 
    return
20565 
 
20566 
 
20567 
  def __repr__(self):
20568 
    L = ['%s=%r' % (key, value)
20569 
      for key, value in self.__dict__.iteritems()]
20570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20571 
 
20572 
  def __eq__(self, other):
20573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20574 
 
20575 
  def __ne__(self, other):
20576 
    return not (self == other)
20577 
 
20578 
class addOrUpdateFreebieForItem_args:
20579 
  """
20580 
  Attributes:
20581 
   - freebieItem
20582 
  """
20583 
 
20584 
  thrift_spec = (
20585 
    None, # 0
20586 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
20587 
  )
20588 
 
20589 
  def __init__(self, freebieItem=None,):
20590 
    self.freebieItem = freebieItem
20591 
 
20592 
  def read(self, iprot):
20593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20595 
      return
20596 
    iprot.readStructBegin()
20597 
    while True:
20598 
      (fname, ftype, fid) = iprot.readFieldBegin()
20599 
      if ftype == TType.STOP:
20600 
        break
20601 
      if fid == 1:
20602 
        if ftype == TType.STRUCT:
20603 
          self.freebieItem = FreebieItem()
20604 
          self.freebieItem.read(iprot)
20605 
        else:
20606 
          iprot.skip(ftype)
20607 
      else:
20608 
        iprot.skip(ftype)
20609 
      iprot.readFieldEnd()
20610 
    iprot.readStructEnd()
20611 
 
20612 
  def write(self, oprot):
20613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20615 
      return
20616 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
20617 
    if self.freebieItem is not None:
20618 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
20619 
      self.freebieItem.write(oprot)
20620 
      oprot.writeFieldEnd()
20621 
    oprot.writeFieldStop()
20622 
    oprot.writeStructEnd()
20623 
 
20624 
  def validate(self):
20625 
    return
20626 
 
20627 
 
20628 
  def __repr__(self):
20629 
    L = ['%s=%r' % (key, value)
20630 
      for key, value in self.__dict__.iteritems()]
20631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20632 
 
20633 
  def __eq__(self, other):
20634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20635 
 
20636 
  def __ne__(self, other):
20637 
    return not (self == other)
20638 
 
20639 
class addOrUpdateFreebieForItem_result:
20640 
 
20641 
  thrift_spec = (
20642 
  )
20643 
 
20644 
  def read(self, iprot):
20645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20647 
      return
20648 
    iprot.readStructBegin()
20649 
    while True:
20650 
      (fname, ftype, fid) = iprot.readFieldBegin()
20651 
      if ftype == TType.STOP:
20652 
        break
20653 
      else:
20654 
        iprot.skip(ftype)
20655 
      iprot.readFieldEnd()
20656 
    iprot.readStructEnd()
20657 
 
20658 
  def write(self, oprot):
20659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20661 
      return
20662 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
20663 
    oprot.writeFieldStop()
20664 
    oprot.writeStructEnd()
20665 
 
20666 
  def validate(self):
20667 
    return
20668 
 
20669 
 
20670 
  def __repr__(self):
20671 
    L = ['%s=%r' % (key, value)
20672 
      for key, value in self.__dict__.iteritems()]
20673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20674 
 
20675 
  def __eq__(self, other):
20676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20677 
 
20678 
  def __ne__(self, other):
20679 
    return not (self == other)
7256 rajveer 20680 
 
7272 amit.gupta 20681 
class addOrUpdateBrandInfo_args:
20682 
  """
20683 
  Attributes:
20684 
   - brandInfo
20685 
  """
20686 
 
20687 
  thrift_spec = (
20688 
    None, # 0
20689 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
20690 
  )
20691 
 
20692 
  def __init__(self, brandInfo=None,):
20693 
    self.brandInfo = brandInfo
20694 
 
20695 
  def read(self, iprot):
20696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20698 
      return
20699 
    iprot.readStructBegin()
20700 
    while True:
20701 
      (fname, ftype, fid) = iprot.readFieldBegin()
20702 
      if ftype == TType.STOP:
20703 
        break
20704 
      if fid == 1:
20705 
        if ftype == TType.STRUCT:
20706 
          self.brandInfo = BrandInfo()
20707 
          self.brandInfo.read(iprot)
20708 
        else:
20709 
          iprot.skip(ftype)
20710 
      else:
20711 
        iprot.skip(ftype)
20712 
      iprot.readFieldEnd()
20713 
    iprot.readStructEnd()
20714 
 
20715 
  def write(self, oprot):
20716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20718 
      return
20719 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
20720 
    if self.brandInfo is not None:
20721 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
20722 
      self.brandInfo.write(oprot)
20723 
      oprot.writeFieldEnd()
20724 
    oprot.writeFieldStop()
20725 
    oprot.writeStructEnd()
20726 
 
20727 
  def validate(self):
20728 
    return
20729 
 
20730 
 
20731 
  def __repr__(self):
20732 
    L = ['%s=%r' % (key, value)
20733 
      for key, value in self.__dict__.iteritems()]
20734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20735 
 
20736 
  def __eq__(self, other):
20737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20738 
 
20739 
  def __ne__(self, other):
20740 
    return not (self == other)
20741 
 
20742 
class addOrUpdateBrandInfo_result:
20743 
 
20744 
  thrift_spec = (
20745 
  )
20746 
 
20747 
  def read(self, iprot):
20748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20750 
      return
20751 
    iprot.readStructBegin()
20752 
    while True:
20753 
      (fname, ftype, fid) = iprot.readFieldBegin()
20754 
      if ftype == TType.STOP:
20755 
        break
20756 
      else:
20757 
        iprot.skip(ftype)
20758 
      iprot.readFieldEnd()
20759 
    iprot.readStructEnd()
20760 
 
20761 
  def write(self, oprot):
20762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20764 
      return
20765 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
20766 
    oprot.writeFieldStop()
20767 
    oprot.writeStructEnd()
20768 
 
20769 
  def validate(self):
20770 
    return
20771 
 
20772 
 
20773 
  def __repr__(self):
20774 
    L = ['%s=%r' % (key, value)
20775 
      for key, value in self.__dict__.iteritems()]
20776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20777 
 
20778 
  def __eq__(self, other):
20779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20780 
 
20781 
  def __ne__(self, other):
20782 
    return not (self == other)
20783 
 
20784 
class getBrandInfo_args:
20785 
 
20786 
  thrift_spec = (
20787 
  )
20788 
 
20789 
  def read(self, iprot):
20790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20792 
      return
20793 
    iprot.readStructBegin()
20794 
    while True:
20795 
      (fname, ftype, fid) = iprot.readFieldBegin()
20796 
      if ftype == TType.STOP:
20797 
        break
20798 
      else:
20799 
        iprot.skip(ftype)
20800 
      iprot.readFieldEnd()
20801 
    iprot.readStructEnd()
20802 
 
20803 
  def write(self, oprot):
20804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20806 
      return
20807 
    oprot.writeStructBegin('getBrandInfo_args')
20808 
    oprot.writeFieldStop()
20809 
    oprot.writeStructEnd()
20810 
 
20811 
  def validate(self):
20812 
    return
20813 
 
20814 
 
20815 
  def __repr__(self):
20816 
    L = ['%s=%r' % (key, value)
20817 
      for key, value in self.__dict__.iteritems()]
20818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20819 
 
20820 
  def __eq__(self, other):
20821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20822 
 
20823 
  def __ne__(self, other):
20824 
    return not (self == other)
20825 
 
20826 
class getBrandInfo_result:
20827 
  """
20828 
  Attributes:
20829 
   - success
20830 
  """
20831 
 
20832 
  thrift_spec = (
20833 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
20834 
  )
20835 
 
20836 
  def __init__(self, success=None,):
20837 
    self.success = success
20838 
 
20839 
  def read(self, iprot):
20840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20842 
      return
20843 
    iprot.readStructBegin()
20844 
    while True:
20845 
      (fname, ftype, fid) = iprot.readFieldBegin()
20846 
      if ftype == TType.STOP:
20847 
        break
20848 
      if fid == 0:
20849 
        if ftype == TType.MAP:
20850 
          self.success = {}
9155 kshitij.so 20851 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
20852 
          for _i392 in xrange(_size388):
20853 
            _key393 = iprot.readString();
20854 
            _val394 = BrandInfo()
20855 
            _val394.read(iprot)
20856 
            self.success[_key393] = _val394
7272 amit.gupta 20857 
          iprot.readMapEnd()
20858 
        else:
20859 
          iprot.skip(ftype)
20860 
      else:
20861 
        iprot.skip(ftype)
20862 
      iprot.readFieldEnd()
20863 
    iprot.readStructEnd()
20864 
 
20865 
  def write(self, oprot):
20866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20868 
      return
20869 
    oprot.writeStructBegin('getBrandInfo_result')
20870 
    if self.success is not None:
20871 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20872 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 20873 
      for kiter395,viter396 in self.success.items():
20874 
        oprot.writeString(kiter395)
20875 
        viter396.write(oprot)
7272 amit.gupta 20876 
      oprot.writeMapEnd()
20877 
      oprot.writeFieldEnd()
20878 
    oprot.writeFieldStop()
20879 
    oprot.writeStructEnd()
20880 
 
20881 
  def validate(self):
20882 
    return
20883 
 
20884 
 
20885 
  def __repr__(self):
20886 
    L = ['%s=%r' % (key, value)
20887 
      for key, value in self.__dict__.iteritems()]
20888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20889 
 
20890 
  def __eq__(self, other):
20891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20892 
 
20893 
  def __ne__(self, other):
20894 
    return not (self == other)
20895 
 
7256 rajveer 20896 
class getStorePricing_args:
20897 
  """
20898 
  Attributes:
20899 
   - itemId
20900 
  """
20901 
 
20902 
  thrift_spec = (
20903 
    None, # 0
20904 
    (1, TType.I64, 'itemId', None, None, ), # 1
20905 
  )
20906 
 
20907 
  def __init__(self, itemId=None,):
20908 
    self.itemId = itemId
20909 
 
20910 
  def read(self, iprot):
20911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20913 
      return
20914 
    iprot.readStructBegin()
20915 
    while True:
20916 
      (fname, ftype, fid) = iprot.readFieldBegin()
20917 
      if ftype == TType.STOP:
20918 
        break
20919 
      if fid == 1:
20920 
        if ftype == TType.I64:
20921 
          self.itemId = iprot.readI64();
20922 
        else:
20923 
          iprot.skip(ftype)
20924 
      else:
20925 
        iprot.skip(ftype)
20926 
      iprot.readFieldEnd()
20927 
    iprot.readStructEnd()
20928 
 
20929 
  def write(self, oprot):
20930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20932 
      return
20933 
    oprot.writeStructBegin('getStorePricing_args')
20934 
    if self.itemId is not None:
20935 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20936 
      oprot.writeI64(self.itemId)
20937 
      oprot.writeFieldEnd()
20938 
    oprot.writeFieldStop()
20939 
    oprot.writeStructEnd()
20940 
 
20941 
  def validate(self):
20942 
    return
20943 
 
20944 
 
20945 
  def __repr__(self):
20946 
    L = ['%s=%r' % (key, value)
20947 
      for key, value in self.__dict__.iteritems()]
20948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20949 
 
20950 
  def __eq__(self, other):
20951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20952 
 
20953 
  def __ne__(self, other):
20954 
    return not (self == other)
20955 
 
20956 
class getStorePricing_result:
20957 
  """
20958 
  Attributes:
20959 
   - success
20960 
  """
20961 
 
20962 
  thrift_spec = (
20963 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
20964 
  )
20965 
 
20966 
  def __init__(self, success=None,):
20967 
    self.success = success
20968 
 
20969 
  def read(self, iprot):
20970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20972 
      return
20973 
    iprot.readStructBegin()
20974 
    while True:
20975 
      (fname, ftype, fid) = iprot.readFieldBegin()
20976 
      if ftype == TType.STOP:
20977 
        break
20978 
      if fid == 0:
20979 
        if ftype == TType.STRUCT:
20980 
          self.success = StorePricing()
20981 
          self.success.read(iprot)
20982 
        else:
20983 
          iprot.skip(ftype)
20984 
      else:
20985 
        iprot.skip(ftype)
20986 
      iprot.readFieldEnd()
20987 
    iprot.readStructEnd()
20988 
 
20989 
  def write(self, oprot):
20990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20992 
      return
20993 
    oprot.writeStructBegin('getStorePricing_result')
20994 
    if self.success is not None:
20995 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20996 
      self.success.write(oprot)
20997 
      oprot.writeFieldEnd()
20998 
    oprot.writeFieldStop()
20999 
    oprot.writeStructEnd()
21000 
 
21001 
  def validate(self):
21002 
    return
21003 
 
21004 
 
21005 
  def __repr__(self):
21006 
    L = ['%s=%r' % (key, value)
21007 
      for key, value in self.__dict__.iteritems()]
21008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21009 
 
21010 
  def __eq__(self, other):
21011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21012 
 
21013 
  def __ne__(self, other):
21014 
    return not (self == other)
7265 rajveer 21015 
 
7306 rajveer 21016 
class getStorePricings_args:
21017 
  """
21018 
  Attributes:
21019 
   - itemIds
21020 
  """
21021 
 
21022 
  thrift_spec = (
21023 
    None, # 0
21024 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
21025 
  )
21026 
 
21027 
  def __init__(self, itemIds=None,):
21028 
    self.itemIds = itemIds
21029 
 
21030 
  def read(self, iprot):
21031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21033 
      return
21034 
    iprot.readStructBegin()
21035 
    while True:
21036 
      (fname, ftype, fid) = iprot.readFieldBegin()
21037 
      if ftype == TType.STOP:
21038 
        break
21039 
      if fid == 1:
21040 
        if ftype == TType.LIST:
21041 
          self.itemIds = []
9155 kshitij.so 21042 
          (_etype400, _size397) = iprot.readListBegin()
21043 
          for _i401 in xrange(_size397):
21044 
            _elem402 = iprot.readI64();
21045 
            self.itemIds.append(_elem402)
7306 rajveer 21046 
          iprot.readListEnd()
21047 
        else:
21048 
          iprot.skip(ftype)
21049 
      else:
21050 
        iprot.skip(ftype)
21051 
      iprot.readFieldEnd()
21052 
    iprot.readStructEnd()
21053 
 
21054 
  def write(self, oprot):
21055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21057 
      return
21058 
    oprot.writeStructBegin('getStorePricings_args')
21059 
    if self.itemIds is not None:
21060 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
21061 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 21062 
      for iter403 in self.itemIds:
21063 
        oprot.writeI64(iter403)
7306 rajveer 21064 
      oprot.writeListEnd()
21065 
      oprot.writeFieldEnd()
21066 
    oprot.writeFieldStop()
21067 
    oprot.writeStructEnd()
21068 
 
21069 
  def validate(self):
21070 
    return
21071 
 
21072 
 
21073 
  def __repr__(self):
21074 
    L = ['%s=%r' % (key, value)
21075 
      for key, value in self.__dict__.iteritems()]
21076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21077 
 
21078 
  def __eq__(self, other):
21079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21080 
 
21081 
  def __ne__(self, other):
21082 
    return not (self == other)
21083 
 
21084 
class getStorePricings_result:
21085 
  """
21086 
  Attributes:
21087 
   - success
21088 
  """
21089 
 
21090 
  thrift_spec = (
21091 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
21092 
  )
21093 
 
21094 
  def __init__(self, success=None,):
21095 
    self.success = success
21096 
 
21097 
  def read(self, iprot):
21098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21100 
      return
21101 
    iprot.readStructBegin()
21102 
    while True:
21103 
      (fname, ftype, fid) = iprot.readFieldBegin()
21104 
      if ftype == TType.STOP:
21105 
        break
21106 
      if fid == 0:
21107 
        if ftype == TType.LIST:
21108 
          self.success = []
9155 kshitij.so 21109 
          (_etype407, _size404) = iprot.readListBegin()
21110 
          for _i408 in xrange(_size404):
21111 
            _elem409 = StorePricing()
21112 
            _elem409.read(iprot)
21113 
            self.success.append(_elem409)
7306 rajveer 21114 
          iprot.readListEnd()
21115 
        else:
21116 
          iprot.skip(ftype)
21117 
      else:
21118 
        iprot.skip(ftype)
21119 
      iprot.readFieldEnd()
21120 
    iprot.readStructEnd()
21121 
 
21122 
  def write(self, oprot):
21123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21125 
      return
21126 
    oprot.writeStructBegin('getStorePricings_result')
21127 
    if self.success is not None:
21128 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21129 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21130 
      for iter410 in self.success:
21131 
        iter410.write(oprot)
7306 rajveer 21132 
      oprot.writeListEnd()
21133 
      oprot.writeFieldEnd()
21134 
    oprot.writeFieldStop()
21135 
    oprot.writeStructEnd()
21136 
 
21137 
  def validate(self):
21138 
    return
21139 
 
21140 
 
21141 
  def __repr__(self):
21142 
    L = ['%s=%r' % (key, value)
21143 
      for key, value in self.__dict__.iteritems()]
21144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21145 
 
21146 
  def __eq__(self, other):
21147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21148 
 
21149 
  def __ne__(self, other):
21150 
    return not (self == other)
21151 
 
7265 rajveer 21152 
class updateStorePricing_args:
21153 
  """
21154 
  Attributes:
21155 
   - sp
7382 rajveer 21156 
   - allColors
7265 rajveer 21157 
  """
21158 
 
21159 
  thrift_spec = (
21160 
    None, # 0
21161 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 21162 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 21163 
  )
21164 
 
7382 rajveer 21165 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 21166 
    self.sp = sp
7382 rajveer 21167 
    self.allColors = allColors
7265 rajveer 21168 
 
21169 
  def read(self, iprot):
21170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21172 
      return
21173 
    iprot.readStructBegin()
21174 
    while True:
21175 
      (fname, ftype, fid) = iprot.readFieldBegin()
21176 
      if ftype == TType.STOP:
21177 
        break
21178 
      if fid == 1:
21179 
        if ftype == TType.STRUCT:
21180 
          self.sp = StorePricing()
21181 
          self.sp.read(iprot)
21182 
        else:
21183 
          iprot.skip(ftype)
7382 rajveer 21184 
      elif fid == 2:
21185 
        if ftype == TType.BOOL:
21186 
          self.allColors = iprot.readBool();
21187 
        else:
21188 
          iprot.skip(ftype)
7265 rajveer 21189 
      else:
21190 
        iprot.skip(ftype)
21191 
      iprot.readFieldEnd()
21192 
    iprot.readStructEnd()
21193 
 
21194 
  def write(self, oprot):
21195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21197 
      return
21198 
    oprot.writeStructBegin('updateStorePricing_args')
21199 
    if self.sp is not None:
21200 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
21201 
      self.sp.write(oprot)
21202 
      oprot.writeFieldEnd()
7382 rajveer 21203 
    if self.allColors is not None:
21204 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
21205 
      oprot.writeBool(self.allColors)
21206 
      oprot.writeFieldEnd()
7265 rajveer 21207 
    oprot.writeFieldStop()
21208 
    oprot.writeStructEnd()
21209 
 
21210 
  def validate(self):
21211 
    return
21212 
 
21213 
 
21214 
  def __repr__(self):
21215 
    L = ['%s=%r' % (key, value)
21216 
      for key, value in self.__dict__.iteritems()]
21217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21218 
 
21219 
  def __eq__(self, other):
21220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21221 
 
21222 
  def __ne__(self, other):
21223 
    return not (self == other)
21224 
 
21225 
class updateStorePricing_result:
21226 
 
21227 
  thrift_spec = (
21228 
  )
21229 
 
21230 
  def read(self, iprot):
21231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21233 
      return
21234 
    iprot.readStructBegin()
21235 
    while True:
21236 
      (fname, ftype, fid) = iprot.readFieldBegin()
21237 
      if ftype == TType.STOP:
21238 
        break
21239 
      else:
21240 
        iprot.skip(ftype)
21241 
      iprot.readFieldEnd()
21242 
    iprot.readStructEnd()
21243 
 
21244 
  def write(self, oprot):
21245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21247 
      return
21248 
    oprot.writeStructBegin('updateStorePricing_result')
21249 
    oprot.writeFieldStop()
21250 
    oprot.writeStructEnd()
21251 
 
21252 
  def validate(self):
21253 
    return
21254 
 
21255 
 
21256 
  def __repr__(self):
21257 
    L = ['%s=%r' % (key, value)
21258 
      for key, value in self.__dict__.iteritems()]
21259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21260 
 
21261 
  def __eq__(self, other):
21262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21263 
 
21264 
  def __ne__(self, other):
21265 
    return not (self == other)
7281 kshitij.so 21266 
 
21267 
class getAllAmazonListedItems_args:
21268 
 
21269 
  thrift_spec = (
21270 
  )
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 
      else:
21282 
        iprot.skip(ftype)
21283 
      iprot.readFieldEnd()
21284 
    iprot.readStructEnd()
21285 
 
21286 
  def write(self, oprot):
21287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21289 
      return
21290 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
21291 
    oprot.writeFieldStop()
21292 
    oprot.writeStructEnd()
21293 
 
21294 
  def validate(self):
21295 
    return
21296 
 
21297 
 
21298 
  def __repr__(self):
21299 
    L = ['%s=%r' % (key, value)
21300 
      for key, value in self.__dict__.iteritems()]
21301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21302 
 
21303 
  def __eq__(self, other):
21304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21305 
 
21306 
  def __ne__(self, other):
21307 
    return not (self == other)
21308 
 
21309 
class getAllAmazonListedItems_result:
21310 
  """
21311 
  Attributes:
21312 
   - success
21313 
  """
21314 
 
21315 
  thrift_spec = (
21316 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21317 
  )
21318 
 
21319 
  def __init__(self, success=None,):
21320 
    self.success = success
21321 
 
21322 
  def read(self, iprot):
21323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21325 
      return
21326 
    iprot.readStructBegin()
21327 
    while True:
21328 
      (fname, ftype, fid) = iprot.readFieldBegin()
21329 
      if ftype == TType.STOP:
21330 
        break
21331 
      if fid == 0:
21332 
        if ftype == TType.LIST:
21333 
          self.success = []
9155 kshitij.so 21334 
          (_etype414, _size411) = iprot.readListBegin()
21335 
          for _i415 in xrange(_size411):
21336 
            _elem416 = Amazonlisted()
21337 
            _elem416.read(iprot)
21338 
            self.success.append(_elem416)
7281 kshitij.so 21339 
          iprot.readListEnd()
21340 
        else:
21341 
          iprot.skip(ftype)
21342 
      else:
21343 
        iprot.skip(ftype)
21344 
      iprot.readFieldEnd()
21345 
    iprot.readStructEnd()
21346 
 
21347 
  def write(self, oprot):
21348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21350 
      return
21351 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
21352 
    if self.success is not None:
21353 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21354 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21355 
      for iter417 in self.success:
21356 
        iter417.write(oprot)
7281 kshitij.so 21357 
      oprot.writeListEnd()
21358 
      oprot.writeFieldEnd()
21359 
    oprot.writeFieldStop()
21360 
    oprot.writeStructEnd()
21361 
 
21362 
  def validate(self):
21363 
    return
21364 
 
21365 
 
21366 
  def __repr__(self):
21367 
    L = ['%s=%r' % (key, value)
21368 
      for key, value in self.__dict__.iteritems()]
21369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21370 
 
21371 
  def __eq__(self, other):
21372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21373 
 
21374 
  def __ne__(self, other):
21375 
    return not (self == other)
21376 
 
8619 kshitij.so 21377 
class searchAmazonItems_args:
21378 
  """
21379 
  Attributes:
21380 
   - searchTerm
21381 
   - offset
21382 
   - limit
21383 
  """
21384 
 
21385 
  thrift_spec = (
21386 
    None, # 0
21387 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
21388 
    (2, TType.I64, 'offset', None, None, ), # 2
21389 
    (3, TType.I64, 'limit', None, None, ), # 3
21390 
  )
21391 
 
21392 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
21393 
    self.searchTerm = searchTerm
21394 
    self.offset = offset
21395 
    self.limit = limit
21396 
 
21397 
  def read(self, iprot):
21398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21400 
      return
21401 
    iprot.readStructBegin()
21402 
    while True:
21403 
      (fname, ftype, fid) = iprot.readFieldBegin()
21404 
      if ftype == TType.STOP:
21405 
        break
21406 
      if fid == 1:
21407 
        if ftype == TType.LIST:
21408 
          self.searchTerm = []
9155 kshitij.so 21409 
          (_etype421, _size418) = iprot.readListBegin()
21410 
          for _i422 in xrange(_size418):
21411 
            _elem423 = iprot.readString();
21412 
            self.searchTerm.append(_elem423)
8619 kshitij.so 21413 
          iprot.readListEnd()
21414 
        else:
21415 
          iprot.skip(ftype)
21416 
      elif fid == 2:
21417 
        if ftype == TType.I64:
21418 
          self.offset = iprot.readI64();
21419 
        else:
21420 
          iprot.skip(ftype)
21421 
      elif fid == 3:
21422 
        if ftype == TType.I64:
21423 
          self.limit = iprot.readI64();
21424 
        else:
21425 
          iprot.skip(ftype)
21426 
      else:
21427 
        iprot.skip(ftype)
21428 
      iprot.readFieldEnd()
21429 
    iprot.readStructEnd()
21430 
 
21431 
  def write(self, oprot):
21432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21434 
      return
21435 
    oprot.writeStructBegin('searchAmazonItems_args')
21436 
    if self.searchTerm is not None:
21437 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
21438 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 21439 
      for iter424 in self.searchTerm:
21440 
        oprot.writeString(iter424)
8619 kshitij.so 21441 
      oprot.writeListEnd()
21442 
      oprot.writeFieldEnd()
21443 
    if self.offset is not None:
21444 
      oprot.writeFieldBegin('offset', TType.I64, 2)
21445 
      oprot.writeI64(self.offset)
21446 
      oprot.writeFieldEnd()
21447 
    if self.limit is not None:
21448 
      oprot.writeFieldBegin('limit', TType.I64, 3)
21449 
      oprot.writeI64(self.limit)
21450 
      oprot.writeFieldEnd()
21451 
    oprot.writeFieldStop()
21452 
    oprot.writeStructEnd()
21453 
 
21454 
  def validate(self):
21455 
    return
21456 
 
21457 
 
21458 
  def __repr__(self):
21459 
    L = ['%s=%r' % (key, value)
21460 
      for key, value in self.__dict__.iteritems()]
21461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21462 
 
21463 
  def __eq__(self, other):
21464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21465 
 
21466 
  def __ne__(self, other):
21467 
    return not (self == other)
21468 
 
21469 
class searchAmazonItems_result:
21470 
  """
21471 
  Attributes:
21472 
   - success
21473 
  """
21474 
 
21475 
  thrift_spec = (
21476 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21477 
  )
21478 
 
21479 
  def __init__(self, success=None,):
21480 
    self.success = success
21481 
 
21482 
  def read(self, iprot):
21483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21485 
      return
21486 
    iprot.readStructBegin()
21487 
    while True:
21488 
      (fname, ftype, fid) = iprot.readFieldBegin()
21489 
      if ftype == TType.STOP:
21490 
        break
21491 
      if fid == 0:
21492 
        if ftype == TType.LIST:
21493 
          self.success = []
9155 kshitij.so 21494 
          (_etype428, _size425) = iprot.readListBegin()
21495 
          for _i429 in xrange(_size425):
21496 
            _elem430 = Amazonlisted()
21497 
            _elem430.read(iprot)
21498 
            self.success.append(_elem430)
8619 kshitij.so 21499 
          iprot.readListEnd()
21500 
        else:
21501 
          iprot.skip(ftype)
21502 
      else:
21503 
        iprot.skip(ftype)
21504 
      iprot.readFieldEnd()
21505 
    iprot.readStructEnd()
21506 
 
21507 
  def write(self, oprot):
21508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21510 
      return
21511 
    oprot.writeStructBegin('searchAmazonItems_result')
21512 
    if self.success is not None:
21513 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21514 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21515 
      for iter431 in self.success:
21516 
        iter431.write(oprot)
8619 kshitij.so 21517 
      oprot.writeListEnd()
21518 
      oprot.writeFieldEnd()
21519 
    oprot.writeFieldStop()
21520 
    oprot.writeStructEnd()
21521 
 
21522 
  def validate(self):
21523 
    return
21524 
 
21525 
 
21526 
  def __repr__(self):
21527 
    L = ['%s=%r' % (key, value)
21528 
      for key, value in self.__dict__.iteritems()]
21529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21530 
 
21531 
  def __eq__(self, other):
21532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21533 
 
21534 
  def __ne__(self, other):
21535 
    return not (self == other)
21536 
 
21537 
class getAmazonSearchResultCount_args:
21538 
  """
21539 
  Attributes:
21540 
   - searchTerm
21541 
  """
21542 
 
21543 
  thrift_spec = (
21544 
    None, # 0
21545 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
21546 
  )
21547 
 
21548 
  def __init__(self, searchTerm=None,):
21549 
    self.searchTerm = searchTerm
21550 
 
21551 
  def read(self, iprot):
21552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21554 
      return
21555 
    iprot.readStructBegin()
21556 
    while True:
21557 
      (fname, ftype, fid) = iprot.readFieldBegin()
21558 
      if ftype == TType.STOP:
21559 
        break
21560 
      if fid == 1:
21561 
        if ftype == TType.LIST:
21562 
          self.searchTerm = []
9155 kshitij.so 21563 
          (_etype435, _size432) = iprot.readListBegin()
21564 
          for _i436 in xrange(_size432):
21565 
            _elem437 = iprot.readString();
21566 
            self.searchTerm.append(_elem437)
8619 kshitij.so 21567 
          iprot.readListEnd()
21568 
        else:
21569 
          iprot.skip(ftype)
21570 
      else:
21571 
        iprot.skip(ftype)
21572 
      iprot.readFieldEnd()
21573 
    iprot.readStructEnd()
21574 
 
21575 
  def write(self, oprot):
21576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21578 
      return
21579 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
21580 
    if self.searchTerm is not None:
21581 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
21582 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 21583 
      for iter438 in self.searchTerm:
21584 
        oprot.writeString(iter438)
8619 kshitij.so 21585 
      oprot.writeListEnd()
21586 
      oprot.writeFieldEnd()
21587 
    oprot.writeFieldStop()
21588 
    oprot.writeStructEnd()
21589 
 
21590 
  def validate(self):
21591 
    return
21592 
 
21593 
 
21594 
  def __repr__(self):
21595 
    L = ['%s=%r' % (key, value)
21596 
      for key, value in self.__dict__.iteritems()]
21597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21598 
 
21599 
  def __eq__(self, other):
21600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21601 
 
21602 
  def __ne__(self, other):
21603 
    return not (self == other)
21604 
 
21605 
class getAmazonSearchResultCount_result:
21606 
  """
21607 
  Attributes:
21608 
   - success
21609 
  """
21610 
 
21611 
  thrift_spec = (
21612 
    (0, TType.I64, 'success', None, None, ), # 0
21613 
  )
21614 
 
21615 
  def __init__(self, success=None,):
21616 
    self.success = success
21617 
 
21618 
  def read(self, iprot):
21619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21621 
      return
21622 
    iprot.readStructBegin()
21623 
    while True:
21624 
      (fname, ftype, fid) = iprot.readFieldBegin()
21625 
      if ftype == TType.STOP:
21626 
        break
21627 
      if fid == 0:
21628 
        if ftype == TType.I64:
21629 
          self.success = iprot.readI64();
21630 
        else:
21631 
          iprot.skip(ftype)
21632 
      else:
21633 
        iprot.skip(ftype)
21634 
      iprot.readFieldEnd()
21635 
    iprot.readStructEnd()
21636 
 
21637 
  def write(self, oprot):
21638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21640 
      return
21641 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
21642 
    if self.success is not None:
21643 
      oprot.writeFieldBegin('success', TType.I64, 0)
21644 
      oprot.writeI64(self.success)
21645 
      oprot.writeFieldEnd()
21646 
    oprot.writeFieldStop()
21647 
    oprot.writeStructEnd()
21648 
 
21649 
  def validate(self):
21650 
    return
21651 
 
21652 
 
21653 
  def __repr__(self):
21654 
    L = ['%s=%r' % (key, value)
21655 
      for key, value in self.__dict__.iteritems()]
21656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21657 
 
21658 
  def __eq__(self, other):
21659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21660 
 
21661 
  def __ne__(self, other):
21662 
    return not (self == other)
21663 
 
21664 
class getCountForAmazonlistedItems_args:
21665 
 
21666 
  thrift_spec = (
21667 
  )
21668 
 
21669 
  def read(self, iprot):
21670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21672 
      return
21673 
    iprot.readStructBegin()
21674 
    while True:
21675 
      (fname, ftype, fid) = iprot.readFieldBegin()
21676 
      if ftype == TType.STOP:
21677 
        break
21678 
      else:
21679 
        iprot.skip(ftype)
21680 
      iprot.readFieldEnd()
21681 
    iprot.readStructEnd()
21682 
 
21683 
  def write(self, oprot):
21684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21686 
      return
21687 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
21688 
    oprot.writeFieldStop()
21689 
    oprot.writeStructEnd()
21690 
 
21691 
  def validate(self):
21692 
    return
21693 
 
21694 
 
21695 
  def __repr__(self):
21696 
    L = ['%s=%r' % (key, value)
21697 
      for key, value in self.__dict__.iteritems()]
21698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21699 
 
21700 
  def __eq__(self, other):
21701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21702 
 
21703 
  def __ne__(self, other):
21704 
    return not (self == other)
21705 
 
21706 
class getCountForAmazonlistedItems_result:
21707 
  """
21708 
  Attributes:
21709 
   - success
21710 
  """
21711 
 
21712 
  thrift_spec = (
21713 
    (0, TType.I64, 'success', None, None, ), # 0
21714 
  )
21715 
 
21716 
  def __init__(self, success=None,):
21717 
    self.success = success
21718 
 
21719 
  def read(self, iprot):
21720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21722 
      return
21723 
    iprot.readStructBegin()
21724 
    while True:
21725 
      (fname, ftype, fid) = iprot.readFieldBegin()
21726 
      if ftype == TType.STOP:
21727 
        break
21728 
      if fid == 0:
21729 
        if ftype == TType.I64:
21730 
          self.success = iprot.readI64();
21731 
        else:
21732 
          iprot.skip(ftype)
21733 
      else:
21734 
        iprot.skip(ftype)
21735 
      iprot.readFieldEnd()
21736 
    iprot.readStructEnd()
21737 
 
21738 
  def write(self, oprot):
21739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21741 
      return
21742 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
21743 
    if self.success is not None:
21744 
      oprot.writeFieldBegin('success', TType.I64, 0)
21745 
      oprot.writeI64(self.success)
21746 
      oprot.writeFieldEnd()
21747 
    oprot.writeFieldStop()
21748 
    oprot.writeStructEnd()
21749 
 
21750 
  def validate(self):
21751 
    return
21752 
 
21753 
 
21754 
  def __repr__(self):
21755 
    L = ['%s=%r' % (key, value)
21756 
      for key, value in self.__dict__.iteritems()]
21757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21758 
 
21759 
  def __eq__(self, other):
21760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21761 
 
21762 
  def __ne__(self, other):
21763 
    return not (self == other)
21764 
 
7281 kshitij.so 21765 
class getAmazonItemDetails_args:
21766 
  """
21767 
  Attributes:
21768 
   - itemId
21769 
  """
21770 
 
21771 
  thrift_spec = (
21772 
    None, # 0
21773 
    (1, TType.I64, 'itemId', None, None, ), # 1
21774 
  )
21775 
 
21776 
  def __init__(self, itemId=None,):
21777 
    self.itemId = itemId
21778 
 
21779 
  def read(self, iprot):
21780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21782 
      return
21783 
    iprot.readStructBegin()
21784 
    while True:
21785 
      (fname, ftype, fid) = iprot.readFieldBegin()
21786 
      if ftype == TType.STOP:
21787 
        break
21788 
      if fid == 1:
21789 
        if ftype == TType.I64:
21790 
          self.itemId = iprot.readI64();
21791 
        else:
21792 
          iprot.skip(ftype)
21793 
      else:
21794 
        iprot.skip(ftype)
21795 
      iprot.readFieldEnd()
21796 
    iprot.readStructEnd()
21797 
 
21798 
  def write(self, oprot):
21799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21801 
      return
21802 
    oprot.writeStructBegin('getAmazonItemDetails_args')
21803 
    if self.itemId is not None:
21804 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21805 
      oprot.writeI64(self.itemId)
21806 
      oprot.writeFieldEnd()
21807 
    oprot.writeFieldStop()
21808 
    oprot.writeStructEnd()
21809 
 
21810 
  def validate(self):
21811 
    return
21812 
 
21813 
 
21814 
  def __repr__(self):
21815 
    L = ['%s=%r' % (key, value)
21816 
      for key, value in self.__dict__.iteritems()]
21817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21818 
 
21819 
  def __eq__(self, other):
21820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21821 
 
21822 
  def __ne__(self, other):
21823 
    return not (self == other)
21824 
 
21825 
class getAmazonItemDetails_result:
21826 
  """
21827 
  Attributes:
21828 
   - success
21829 
  """
21830 
 
21831 
  thrift_spec = (
21832 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
21833 
  )
21834 
 
21835 
  def __init__(self, success=None,):
21836 
    self.success = success
21837 
 
21838 
  def read(self, iprot):
21839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21841 
      return
21842 
    iprot.readStructBegin()
21843 
    while True:
21844 
      (fname, ftype, fid) = iprot.readFieldBegin()
21845 
      if ftype == TType.STOP:
21846 
        break
21847 
      if fid == 0:
21848 
        if ftype == TType.STRUCT:
21849 
          self.success = Amazonlisted()
21850 
          self.success.read(iprot)
21851 
        else:
21852 
          iprot.skip(ftype)
21853 
      else:
21854 
        iprot.skip(ftype)
21855 
      iprot.readFieldEnd()
21856 
    iprot.readStructEnd()
21857 
 
21858 
  def write(self, oprot):
21859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21861 
      return
21862 
    oprot.writeStructBegin('getAmazonItemDetails_result')
21863 
    if self.success is not None:
21864 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21865 
      self.success.write(oprot)
21866 
      oprot.writeFieldEnd()
21867 
    oprot.writeFieldStop()
21868 
    oprot.writeStructEnd()
21869 
 
21870 
  def validate(self):
21871 
    return
21872 
 
21873 
 
21874 
  def __repr__(self):
21875 
    L = ['%s=%r' % (key, value)
21876 
      for key, value in self.__dict__.iteritems()]
21877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21878 
 
21879 
  def __eq__(self, other):
21880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21881 
 
21882 
  def __ne__(self, other):
21883 
    return not (self == other)
21884 
 
21885 
class updateAmazonItemDetails_args:
21886 
  """
21887 
  Attributes:
8168 kshitij.so 21888 
   - amazonlisted
7281 kshitij.so 21889 
  """
21890 
 
21891 
  thrift_spec = (
21892 
    None, # 0
8168 kshitij.so 21893 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 21894 
  )
21895 
 
8168 kshitij.so 21896 
  def __init__(self, amazonlisted=None,):
21897 
    self.amazonlisted = amazonlisted
7281 kshitij.so 21898 
 
21899 
  def read(self, iprot):
21900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21902 
      return
21903 
    iprot.readStructBegin()
21904 
    while True:
21905 
      (fname, ftype, fid) = iprot.readFieldBegin()
21906 
      if ftype == TType.STOP:
21907 
        break
21908 
      if fid == 1:
8168 kshitij.so 21909 
        if ftype == TType.STRUCT:
21910 
          self.amazonlisted = Amazonlisted()
21911 
          self.amazonlisted.read(iprot)
7281 kshitij.so 21912 
        else:
21913 
          iprot.skip(ftype)
21914 
      else:
21915 
        iprot.skip(ftype)
21916 
      iprot.readFieldEnd()
21917 
    iprot.readStructEnd()
21918 
 
21919 
  def write(self, oprot):
21920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21922 
      return
21923 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 21924 
    if self.amazonlisted is not None:
21925 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
21926 
      self.amazonlisted.write(oprot)
7281 kshitij.so 21927 
      oprot.writeFieldEnd()
21928 
    oprot.writeFieldStop()
21929 
    oprot.writeStructEnd()
21930 
 
21931 
  def validate(self):
21932 
    return
21933 
 
21934 
 
21935 
  def __repr__(self):
21936 
    L = ['%s=%r' % (key, value)
21937 
      for key, value in self.__dict__.iteritems()]
21938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21939 
 
21940 
  def __eq__(self, other):
21941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21942 
 
21943 
  def __ne__(self, other):
21944 
    return not (self == other)
21945 
 
21946 
class updateAmazonItemDetails_result:
21947 
 
21948 
  thrift_spec = (
21949 
  )
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 
      else:
21961 
        iprot.skip(ftype)
21962 
      iprot.readFieldEnd()
21963 
    iprot.readStructEnd()
21964 
 
21965 
  def write(self, oprot):
21966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21968 
      return
21969 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
21970 
    oprot.writeFieldStop()
21971 
    oprot.writeStructEnd()
21972 
 
21973 
  def validate(self):
21974 
    return
21975 
 
21976 
 
21977 
  def __repr__(self):
21978 
    L = ['%s=%r' % (key, value)
21979 
      for key, value in self.__dict__.iteritems()]
21980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21981 
 
21982 
  def __eq__(self, other):
21983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21984 
 
21985 
  def __ne__(self, other):
21986 
    return not (self == other)
21987 
 
21988 
class addAmazonItem_args:
21989 
  """
21990 
  Attributes:
21991 
   - amazonlisted
21992 
  """
21993 
 
21994 
  thrift_spec = (
21995 
    None, # 0
21996 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
21997 
  )
21998 
 
21999 
  def __init__(self, amazonlisted=None,):
22000 
    self.amazonlisted = amazonlisted
22001 
 
22002 
  def read(self, iprot):
22003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22005 
      return
22006 
    iprot.readStructBegin()
22007 
    while True:
22008 
      (fname, ftype, fid) = iprot.readFieldBegin()
22009 
      if ftype == TType.STOP:
22010 
        break
22011 
      if fid == 1:
22012 
        if ftype == TType.STRUCT:
22013 
          self.amazonlisted = Amazonlisted()
22014 
          self.amazonlisted.read(iprot)
22015 
        else:
22016 
          iprot.skip(ftype)
22017 
      else:
22018 
        iprot.skip(ftype)
22019 
      iprot.readFieldEnd()
22020 
    iprot.readStructEnd()
22021 
 
22022 
  def write(self, oprot):
22023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22025 
      return
22026 
    oprot.writeStructBegin('addAmazonItem_args')
22027 
    if self.amazonlisted is not None:
22028 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
22029 
      self.amazonlisted.write(oprot)
22030 
      oprot.writeFieldEnd()
22031 
    oprot.writeFieldStop()
22032 
    oprot.writeStructEnd()
22033 
 
22034 
  def validate(self):
22035 
    return
22036 
 
22037 
 
22038 
  def __repr__(self):
22039 
    L = ['%s=%r' % (key, value)
22040 
      for key, value in self.__dict__.iteritems()]
22041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22042 
 
22043 
  def __eq__(self, other):
22044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22045 
 
22046 
  def __ne__(self, other):
22047 
    return not (self == other)
22048 
 
22049 
class addAmazonItem_result:
22050 
 
22051 
  thrift_spec = (
22052 
  )
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 
      else:
22064 
        iprot.skip(ftype)
22065 
      iprot.readFieldEnd()
22066 
    iprot.readStructEnd()
22067 
 
22068 
  def write(self, oprot):
22069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22071 
      return
22072 
    oprot.writeStructBegin('addAmazonItem_result')
22073 
    oprot.writeFieldStop()
22074 
    oprot.writeStructEnd()
22075 
 
22076 
  def validate(self):
22077 
    return
22078 
 
22079 
 
22080 
  def __repr__(self):
22081 
    L = ['%s=%r' % (key, value)
22082 
      for key, value in self.__dict__.iteritems()]
22083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22084 
 
22085 
  def __eq__(self, other):
22086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22087 
 
22088 
  def __ne__(self, other):
22089 
    return not (self == other)
7291 vikram.rag 22090 
 
22091 
class getAsinItems_args:
22092 
 
22093 
  thrift_spec = (
22094 
  )
22095 
 
22096 
  def read(self, iprot):
22097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22099 
      return
22100 
    iprot.readStructBegin()
22101 
    while True:
22102 
      (fname, ftype, fid) = iprot.readFieldBegin()
22103 
      if ftype == TType.STOP:
22104 
        break
22105 
      else:
22106 
        iprot.skip(ftype)
22107 
      iprot.readFieldEnd()
22108 
    iprot.readStructEnd()
22109 
 
22110 
  def write(self, oprot):
22111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22113 
      return
22114 
    oprot.writeStructBegin('getAsinItems_args')
22115 
    oprot.writeFieldStop()
22116 
    oprot.writeStructEnd()
22117 
 
22118 
  def validate(self):
22119 
    return
22120 
 
22121 
 
22122 
  def __repr__(self):
22123 
    L = ['%s=%r' % (key, value)
22124 
      for key, value in self.__dict__.iteritems()]
22125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22126 
 
22127 
  def __eq__(self, other):
22128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22129 
 
22130 
  def __ne__(self, other):
22131 
    return not (self == other)
22132 
 
22133 
class getAsinItems_result:
22134 
  """
22135 
  Attributes:
22136 
   - success
22137 
  """
22138 
 
22139 
  thrift_spec = (
22140 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
22141 
  )
22142 
 
22143 
  def __init__(self, success=None,):
22144 
    self.success = success
22145 
 
22146 
  def read(self, iprot):
22147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22149 
      return
22150 
    iprot.readStructBegin()
22151 
    while True:
22152 
      (fname, ftype, fid) = iprot.readFieldBegin()
22153 
      if ftype == TType.STOP:
22154 
        break
22155 
      if fid == 0:
22156 
        if ftype == TType.LIST:
22157 
          self.success = []
9155 kshitij.so 22158 
          (_etype442, _size439) = iprot.readListBegin()
22159 
          for _i443 in xrange(_size439):
22160 
            _elem444 = Item()
22161 
            _elem444.read(iprot)
22162 
            self.success.append(_elem444)
7291 vikram.rag 22163 
          iprot.readListEnd()
22164 
        else:
22165 
          iprot.skip(ftype)
22166 
      else:
22167 
        iprot.skip(ftype)
22168 
      iprot.readFieldEnd()
22169 
    iprot.readStructEnd()
22170 
 
22171 
  def write(self, oprot):
22172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22174 
      return
22175 
    oprot.writeStructBegin('getAsinItems_result')
22176 
    if self.success is not None:
22177 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22178 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22179 
      for iter445 in self.success:
22180 
        iter445.write(oprot)
7291 vikram.rag 22181 
      oprot.writeListEnd()
22182 
      oprot.writeFieldEnd()
22183 
    oprot.writeFieldStop()
22184 
    oprot.writeStructEnd()
22185 
 
22186 
  def validate(self):
22187 
    return
22188 
 
22189 
 
22190 
  def __repr__(self):
22191 
    L = ['%s=%r' % (key, value)
22192 
      for key, value in self.__dict__.iteritems()]
22193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22194 
 
22195 
  def __eq__(self, other):
22196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22197 
 
22198 
  def __ne__(self, other):
22199 
    return not (self == other)
22200 
 
22201 
class getAllFbaListedItems_args:
22202 
 
22203 
  thrift_spec = (
22204 
  )
22205 
 
22206 
  def read(self, iprot):
22207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22209 
      return
22210 
    iprot.readStructBegin()
22211 
    while True:
22212 
      (fname, ftype, fid) = iprot.readFieldBegin()
22213 
      if ftype == TType.STOP:
22214 
        break
22215 
      else:
22216 
        iprot.skip(ftype)
22217 
      iprot.readFieldEnd()
22218 
    iprot.readStructEnd()
22219 
 
22220 
  def write(self, oprot):
22221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22223 
      return
22224 
    oprot.writeStructBegin('getAllFbaListedItems_args')
22225 
    oprot.writeFieldStop()
22226 
    oprot.writeStructEnd()
22227 
 
22228 
  def validate(self):
22229 
    return
22230 
 
22231 
 
22232 
  def __repr__(self):
22233 
    L = ['%s=%r' % (key, value)
22234 
      for key, value in self.__dict__.iteritems()]
22235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22236 
 
22237 
  def __eq__(self, other):
22238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22239 
 
22240 
  def __ne__(self, other):
22241 
    return not (self == other)
22242 
 
22243 
class getAllFbaListedItems_result:
22244 
  """
22245 
  Attributes:
22246 
   - success
22247 
  """
22248 
 
22249 
  thrift_spec = (
22250 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22251 
  )
22252 
 
22253 
  def __init__(self, success=None,):
22254 
    self.success = success
22255 
 
22256 
  def read(self, iprot):
22257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22259 
      return
22260 
    iprot.readStructBegin()
22261 
    while True:
22262 
      (fname, ftype, fid) = iprot.readFieldBegin()
22263 
      if ftype == TType.STOP:
22264 
        break
22265 
      if fid == 0:
22266 
        if ftype == TType.LIST:
22267 
          self.success = []
9155 kshitij.so 22268 
          (_etype449, _size446) = iprot.readListBegin()
22269 
          for _i450 in xrange(_size446):
22270 
            _elem451 = Amazonlisted()
22271 
            _elem451.read(iprot)
22272 
            self.success.append(_elem451)
7291 vikram.rag 22273 
          iprot.readListEnd()
22274 
        else:
22275 
          iprot.skip(ftype)
22276 
      else:
22277 
        iprot.skip(ftype)
22278 
      iprot.readFieldEnd()
22279 
    iprot.readStructEnd()
22280 
 
22281 
  def write(self, oprot):
22282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22284 
      return
22285 
    oprot.writeStructBegin('getAllFbaListedItems_result')
22286 
    if self.success is not None:
22287 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22288 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22289 
      for iter452 in self.success:
22290 
        iter452.write(oprot)
7291 vikram.rag 22291 
      oprot.writeListEnd()
22292 
      oprot.writeFieldEnd()
22293 
    oprot.writeFieldStop()
22294 
    oprot.writeStructEnd()
22295 
 
22296 
  def validate(self):
22297 
    return
22298 
 
22299 
 
22300 
  def __repr__(self):
22301 
    L = ['%s=%r' % (key, value)
22302 
      for key, value in self.__dict__.iteritems()]
22303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22304 
 
22305 
  def __eq__(self, other):
22306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22307 
 
22308 
  def __ne__(self, other):
22309 
    return not (self == other)
22310 
 
22311 
class getAllNonFbaListedItems_args:
22312 
 
22313 
  thrift_spec = (
22314 
  )
22315 
 
22316 
  def read(self, iprot):
22317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22319 
      return
22320 
    iprot.readStructBegin()
22321 
    while True:
22322 
      (fname, ftype, fid) = iprot.readFieldBegin()
22323 
      if ftype == TType.STOP:
22324 
        break
22325 
      else:
22326 
        iprot.skip(ftype)
22327 
      iprot.readFieldEnd()
22328 
    iprot.readStructEnd()
22329 
 
22330 
  def write(self, oprot):
22331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22333 
      return
22334 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
22335 
    oprot.writeFieldStop()
22336 
    oprot.writeStructEnd()
22337 
 
22338 
  def validate(self):
22339 
    return
22340 
 
22341 
 
22342 
  def __repr__(self):
22343 
    L = ['%s=%r' % (key, value)
22344 
      for key, value in self.__dict__.iteritems()]
22345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22346 
 
22347 
  def __eq__(self, other):
22348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22349 
 
22350 
  def __ne__(self, other):
22351 
    return not (self == other)
22352 
 
22353 
class getAllNonFbaListedItems_result:
22354 
  """
22355 
  Attributes:
22356 
   - success
22357 
  """
22358 
 
22359 
  thrift_spec = (
22360 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22361 
  )
22362 
 
22363 
  def __init__(self, success=None,):
22364 
    self.success = success
22365 
 
22366 
  def read(self, iprot):
22367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22369 
      return
22370 
    iprot.readStructBegin()
22371 
    while True:
22372 
      (fname, ftype, fid) = iprot.readFieldBegin()
22373 
      if ftype == TType.STOP:
22374 
        break
22375 
      if fid == 0:
22376 
        if ftype == TType.LIST:
22377 
          self.success = []
9155 kshitij.so 22378 
          (_etype456, _size453) = iprot.readListBegin()
22379 
          for _i457 in xrange(_size453):
22380 
            _elem458 = Amazonlisted()
22381 
            _elem458.read(iprot)
22382 
            self.success.append(_elem458)
7291 vikram.rag 22383 
          iprot.readListEnd()
22384 
        else:
22385 
          iprot.skip(ftype)
22386 
      else:
22387 
        iprot.skip(ftype)
22388 
      iprot.readFieldEnd()
22389 
    iprot.readStructEnd()
22390 
 
22391 
  def write(self, oprot):
22392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22394 
      return
22395 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
22396 
    if self.success is not None:
22397 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22398 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22399 
      for iter459 in self.success:
22400 
        iter459.write(oprot)
7291 vikram.rag 22401 
      oprot.writeListEnd()
22402 
      oprot.writeFieldEnd()
22403 
    oprot.writeFieldStop()
22404 
    oprot.writeStructEnd()
22405 
 
22406 
  def validate(self):
22407 
    return
22408 
 
22409 
 
22410 
  def __repr__(self):
22411 
    L = ['%s=%r' % (key, value)
22412 
      for key, value in self.__dict__.iteritems()]
22413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22414 
 
22415 
  def __eq__(self, other):
22416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22417 
 
22418 
  def __ne__(self, other):
22419 
    return not (self == other)
7460 kshitij.so 22420 
 
22421 
class updateItemInventory_args:
22422 
  """
22423 
  Attributes:
22424 
   - itemId
22425 
   - holdInventory
22426 
   - defaultInventory
22427 
  """
22428 
 
22429 
  thrift_spec = (
22430 
    None, # 0
22431 
    (1, TType.I64, 'itemId', None, None, ), # 1
22432 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
22433 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
22434 
  )
22435 
 
22436 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
22437 
    self.itemId = itemId
22438 
    self.holdInventory = holdInventory
22439 
    self.defaultInventory = defaultInventory
22440 
 
22441 
  def read(self, iprot):
22442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22444 
      return
22445 
    iprot.readStructBegin()
22446 
    while True:
22447 
      (fname, ftype, fid) = iprot.readFieldBegin()
22448 
      if ftype == TType.STOP:
22449 
        break
22450 
      if fid == 1:
22451 
        if ftype == TType.I64:
22452 
          self.itemId = iprot.readI64();
22453 
        else:
22454 
          iprot.skip(ftype)
22455 
      elif fid == 2:
22456 
        if ftype == TType.I64:
22457 
          self.holdInventory = iprot.readI64();
22458 
        else:
22459 
          iprot.skip(ftype)
22460 
      elif fid == 3:
22461 
        if ftype == TType.I64:
22462 
          self.defaultInventory = iprot.readI64();
22463 
        else:
22464 
          iprot.skip(ftype)
22465 
      else:
22466 
        iprot.skip(ftype)
22467 
      iprot.readFieldEnd()
22468 
    iprot.readStructEnd()
22469 
 
22470 
  def write(self, oprot):
22471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22473 
      return
22474 
    oprot.writeStructBegin('updateItemInventory_args')
22475 
    if self.itemId is not None:
22476 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22477 
      oprot.writeI64(self.itemId)
22478 
      oprot.writeFieldEnd()
22479 
    if self.holdInventory is not None:
22480 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
22481 
      oprot.writeI64(self.holdInventory)
22482 
      oprot.writeFieldEnd()
22483 
    if self.defaultInventory is not None:
22484 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
22485 
      oprot.writeI64(self.defaultInventory)
22486 
      oprot.writeFieldEnd()
22487 
    oprot.writeFieldStop()
22488 
    oprot.writeStructEnd()
22489 
 
22490 
  def validate(self):
22491 
    return
22492 
 
22493 
 
22494 
  def __repr__(self):
22495 
    L = ['%s=%r' % (key, value)
22496 
      for key, value in self.__dict__.iteritems()]
22497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22498 
 
22499 
  def __eq__(self, other):
22500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22501 
 
22502 
  def __ne__(self, other):
22503 
    return not (self == other)
22504 
 
22505 
class updateItemInventory_result:
22506 
  """
22507 
  Attributes:
22508 
   - success
22509 
  """
22510 
 
22511 
  thrift_spec = (
22512 
    (0, TType.BOOL, 'success', None, None, ), # 0
22513 
  )
22514 
 
22515 
  def __init__(self, success=None,):
22516 
    self.success = success
22517 
 
22518 
  def read(self, iprot):
22519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22521 
      return
22522 
    iprot.readStructBegin()
22523 
    while True:
22524 
      (fname, ftype, fid) = iprot.readFieldBegin()
22525 
      if ftype == TType.STOP:
22526 
        break
22527 
      if fid == 0:
22528 
        if ftype == TType.BOOL:
22529 
          self.success = iprot.readBool();
22530 
        else:
22531 
          iprot.skip(ftype)
22532 
      else:
22533 
        iprot.skip(ftype)
22534 
      iprot.readFieldEnd()
22535 
    iprot.readStructEnd()
22536 
 
22537 
  def write(self, oprot):
22538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22540 
      return
22541 
    oprot.writeStructBegin('updateItemInventory_result')
22542 
    if self.success is not None:
22543 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22544 
      oprot.writeBool(self.success)
22545 
      oprot.writeFieldEnd()
22546 
    oprot.writeFieldStop()
22547 
    oprot.writeStructEnd()
22548 
 
22549 
  def validate(self):
22550 
    return
22551 
 
22552 
 
22553 
  def __repr__(self):
22554 
    L = ['%s=%r' % (key, value)
22555 
      for key, value in self.__dict__.iteritems()]
22556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22557 
 
22558 
  def __eq__(self, other):
22559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22560 
 
22561 
  def __ne__(self, other):
22562 
    return not (self == other)
7770 kshitij.so 22563 
 
22564 
class updateTimestampForAmazonFeeds_args:
22565 
  """
22566 
  Attributes:
22567 
   - type
22568 
   - sku
22569 
   - timestamp
22570 
  """
22571 
 
22572 
  thrift_spec = (
22573 
    None, # 0
22574 
    (1, TType.STRING, 'type', None, None, ), # 1
22575 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
22576 
    (3, TType.I64, 'timestamp', None, None, ), # 3
22577 
  )
22578 
 
22579 
  def __init__(self, type=None, sku=None, timestamp=None,):
22580 
    self.type = type
22581 
    self.sku = sku
22582 
    self.timestamp = timestamp
22583 
 
22584 
  def read(self, iprot):
22585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22587 
      return
22588 
    iprot.readStructBegin()
22589 
    while True:
22590 
      (fname, ftype, fid) = iprot.readFieldBegin()
22591 
      if ftype == TType.STOP:
22592 
        break
22593 
      if fid == 1:
22594 
        if ftype == TType.STRING:
22595 
          self.type = iprot.readString();
22596 
        else:
22597 
          iprot.skip(ftype)
22598 
      elif fid == 2:
22599 
        if ftype == TType.LIST:
22600 
          self.sku = []
9155 kshitij.so 22601 
          (_etype463, _size460) = iprot.readListBegin()
22602 
          for _i464 in xrange(_size460):
22603 
            _elem465 = iprot.readI64();
22604 
            self.sku.append(_elem465)
7770 kshitij.so 22605 
          iprot.readListEnd()
22606 
        else:
22607 
          iprot.skip(ftype)
22608 
      elif fid == 3:
22609 
        if ftype == TType.I64:
22610 
          self.timestamp = iprot.readI64();
22611 
        else:
22612 
          iprot.skip(ftype)
22613 
      else:
22614 
        iprot.skip(ftype)
22615 
      iprot.readFieldEnd()
22616 
    iprot.readStructEnd()
22617 
 
22618 
  def write(self, oprot):
22619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22621 
      return
22622 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
22623 
    if self.type is not None:
22624 
      oprot.writeFieldBegin('type', TType.STRING, 1)
22625 
      oprot.writeString(self.type)
22626 
      oprot.writeFieldEnd()
22627 
    if self.sku is not None:
22628 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
22629 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 22630 
      for iter466 in self.sku:
22631 
        oprot.writeI64(iter466)
7770 kshitij.so 22632 
      oprot.writeListEnd()
22633 
      oprot.writeFieldEnd()
22634 
    if self.timestamp is not None:
22635 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
22636 
      oprot.writeI64(self.timestamp)
22637 
      oprot.writeFieldEnd()
22638 
    oprot.writeFieldStop()
22639 
    oprot.writeStructEnd()
22640 
 
22641 
  def validate(self):
22642 
    return
22643 
 
22644 
 
22645 
  def __repr__(self):
22646 
    L = ['%s=%r' % (key, value)
22647 
      for key, value in self.__dict__.iteritems()]
22648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22649 
 
22650 
  def __eq__(self, other):
22651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22652 
 
22653 
  def __ne__(self, other):
22654 
    return not (self == other)
22655 
 
22656 
class updateTimestampForAmazonFeeds_result:
22657 
  """
22658 
  Attributes:
22659 
   - success
22660 
  """
22661 
 
22662 
  thrift_spec = (
22663 
    (0, TType.BOOL, 'success', None, None, ), # 0
22664 
  )
22665 
 
22666 
  def __init__(self, success=None,):
22667 
    self.success = success
22668 
 
22669 
  def read(self, iprot):
22670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22672 
      return
22673 
    iprot.readStructBegin()
22674 
    while True:
22675 
      (fname, ftype, fid) = iprot.readFieldBegin()
22676 
      if ftype == TType.STOP:
22677 
        break
22678 
      if fid == 0:
22679 
        if ftype == TType.BOOL:
22680 
          self.success = iprot.readBool();
22681 
        else:
22682 
          iprot.skip(ftype)
22683 
      else:
22684 
        iprot.skip(ftype)
22685 
      iprot.readFieldEnd()
22686 
    iprot.readStructEnd()
22687 
 
22688 
  def write(self, oprot):
22689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22691 
      return
22692 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
22693 
    if self.success is not None:
22694 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22695 
      oprot.writeBool(self.success)
22696 
      oprot.writeFieldEnd()
22697 
    oprot.writeFieldStop()
22698 
    oprot.writeStructEnd()
22699 
 
22700 
  def validate(self):
22701 
    return
22702 
 
22703 
 
22704 
  def __repr__(self):
22705 
    L = ['%s=%r' % (key, value)
22706 
      for key, value in self.__dict__.iteritems()]
22707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22708 
 
22709 
  def __eq__(self, other):
22710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22711 
 
22712 
  def __ne__(self, other):
22713 
    return not (self == other)
7897 amar.kumar 22714 
 
22715 
class getAllParentCategories_args:
22716 
 
22717 
  thrift_spec = (
22718 
  )
22719 
 
22720 
  def read(self, iprot):
22721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22723 
      return
22724 
    iprot.readStructBegin()
22725 
    while True:
22726 
      (fname, ftype, fid) = iprot.readFieldBegin()
22727 
      if ftype == TType.STOP:
22728 
        break
22729 
      else:
22730 
        iprot.skip(ftype)
22731 
      iprot.readFieldEnd()
22732 
    iprot.readStructEnd()
22733 
 
22734 
  def write(self, oprot):
22735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22737 
      return
22738 
    oprot.writeStructBegin('getAllParentCategories_args')
22739 
    oprot.writeFieldStop()
22740 
    oprot.writeStructEnd()
22741 
 
22742 
  def validate(self):
22743 
    return
22744 
 
22745 
 
22746 
  def __repr__(self):
22747 
    L = ['%s=%r' % (key, value)
22748 
      for key, value in self.__dict__.iteritems()]
22749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22750 
 
22751 
  def __eq__(self, other):
22752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22753 
 
22754 
  def __ne__(self, other):
22755 
    return not (self == other)
22756 
 
22757 
class getAllParentCategories_result:
22758 
  """
22759 
  Attributes:
22760 
   - success
22761 
  """
22762 
 
22763 
  thrift_spec = (
22764 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
22765 
  )
22766 
 
22767 
  def __init__(self, success=None,):
22768 
    self.success = success
22769 
 
22770 
  def read(self, iprot):
22771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22773 
      return
22774 
    iprot.readStructBegin()
22775 
    while True:
22776 
      (fname, ftype, fid) = iprot.readFieldBegin()
22777 
      if ftype == TType.STOP:
22778 
        break
22779 
      if fid == 0:
22780 
        if ftype == TType.LIST:
22781 
          self.success = []
9155 kshitij.so 22782 
          (_etype470, _size467) = iprot.readListBegin()
22783 
          for _i471 in xrange(_size467):
22784 
            _elem472 = Category()
22785 
            _elem472.read(iprot)
22786 
            self.success.append(_elem472)
7897 amar.kumar 22787 
          iprot.readListEnd()
22788 
        else:
22789 
          iprot.skip(ftype)
22790 
      else:
22791 
        iprot.skip(ftype)
22792 
      iprot.readFieldEnd()
22793 
    iprot.readStructEnd()
22794 
 
22795 
  def write(self, oprot):
22796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22798 
      return
22799 
    oprot.writeStructBegin('getAllParentCategories_result')
22800 
    if self.success is not None:
22801 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22802 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22803 
      for iter473 in self.success:
22804 
        iter473.write(oprot)
7897 amar.kumar 22805 
      oprot.writeListEnd()
22806 
      oprot.writeFieldEnd()
22807 
    oprot.writeFieldStop()
22808 
    oprot.writeStructEnd()
22809 
 
22810 
  def validate(self):
22811 
    return
22812 
 
22813 
 
22814 
  def __repr__(self):
22815 
    L = ['%s=%r' % (key, value)
22816 
      for key, value in self.__dict__.iteritems()]
22817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22818 
 
22819 
  def __eq__(self, other):
22820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22821 
 
22822 
  def __ne__(self, other):
22823 
    return not (self == other)
7977 kshitij.so 22824 
 
22825 
class addPageViewEvent_args:
22826 
  """
22827 
  Attributes:
22828 
   - pageViewEvents
22829 
  """
22830 
 
22831 
  thrift_spec = (
22832 
    None, # 0
22833 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
22834 
  )
22835 
 
22836 
  def __init__(self, pageViewEvents=None,):
22837 
    self.pageViewEvents = pageViewEvents
22838 
 
22839 
  def read(self, iprot):
22840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22842 
      return
22843 
    iprot.readStructBegin()
22844 
    while True:
22845 
      (fname, ftype, fid) = iprot.readFieldBegin()
22846 
      if ftype == TType.STOP:
22847 
        break
22848 
      if fid == 1:
22849 
        if ftype == TType.STRUCT:
22850 
          self.pageViewEvents = PageViewEvents()
22851 
          self.pageViewEvents.read(iprot)
22852 
        else:
22853 
          iprot.skip(ftype)
22854 
      else:
22855 
        iprot.skip(ftype)
22856 
      iprot.readFieldEnd()
22857 
    iprot.readStructEnd()
22858 
 
22859 
  def write(self, oprot):
22860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22862 
      return
22863 
    oprot.writeStructBegin('addPageViewEvent_args')
22864 
    if self.pageViewEvents is not None:
22865 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
22866 
      self.pageViewEvents.write(oprot)
22867 
      oprot.writeFieldEnd()
22868 
    oprot.writeFieldStop()
22869 
    oprot.writeStructEnd()
22870 
 
22871 
  def validate(self):
22872 
    return
22873 
 
22874 
 
22875 
  def __repr__(self):
22876 
    L = ['%s=%r' % (key, value)
22877 
      for key, value in self.__dict__.iteritems()]
22878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22879 
 
22880 
  def __eq__(self, other):
22881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22882 
 
22883 
  def __ne__(self, other):
22884 
    return not (self == other)
22885 
 
22886 
class addPageViewEvent_result:
22887 
 
22888 
  thrift_spec = (
22889 
  )
22890 
 
22891 
  def read(self, iprot):
22892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22894 
      return
22895 
    iprot.readStructBegin()
22896 
    while True:
22897 
      (fname, ftype, fid) = iprot.readFieldBegin()
22898 
      if ftype == TType.STOP:
22899 
        break
22900 
      else:
22901 
        iprot.skip(ftype)
22902 
      iprot.readFieldEnd()
22903 
    iprot.readStructEnd()
22904 
 
22905 
  def write(self, oprot):
22906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22908 
      return
22909 
    oprot.writeStructBegin('addPageViewEvent_result')
22910 
    oprot.writeFieldStop()
22911 
    oprot.writeStructEnd()
22912 
 
22913 
  def validate(self):
22914 
    return
22915 
 
22916 
 
22917 
  def __repr__(self):
22918 
    L = ['%s=%r' % (key, value)
22919 
      for key, value in self.__dict__.iteritems()]
22920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22921 
 
22922 
  def __eq__(self, other):
22923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22924 
 
22925 
  def __ne__(self, other):
22926 
    return not (self == other)
22927 
 
22928 
class addCartEvent_args:
22929 
  """
22930 
  Attributes:
22931 
   - cartEvents
22932 
  """
22933 
 
22934 
  thrift_spec = (
22935 
    None, # 0
22936 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
22937 
  )
22938 
 
22939 
  def __init__(self, cartEvents=None,):
22940 
    self.cartEvents = cartEvents
22941 
 
22942 
  def read(self, iprot):
22943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22945 
      return
22946 
    iprot.readStructBegin()
22947 
    while True:
22948 
      (fname, ftype, fid) = iprot.readFieldBegin()
22949 
      if ftype == TType.STOP:
22950 
        break
22951 
      if fid == 1:
22952 
        if ftype == TType.STRUCT:
22953 
          self.cartEvents = CartEvents()
22954 
          self.cartEvents.read(iprot)
22955 
        else:
22956 
          iprot.skip(ftype)
22957 
      else:
22958 
        iprot.skip(ftype)
22959 
      iprot.readFieldEnd()
22960 
    iprot.readStructEnd()
22961 
 
22962 
  def write(self, oprot):
22963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22965 
      return
22966 
    oprot.writeStructBegin('addCartEvent_args')
22967 
    if self.cartEvents is not None:
22968 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
22969 
      self.cartEvents.write(oprot)
22970 
      oprot.writeFieldEnd()
22971 
    oprot.writeFieldStop()
22972 
    oprot.writeStructEnd()
22973 
 
22974 
  def validate(self):
22975 
    return
22976 
 
22977 
 
22978 
  def __repr__(self):
22979 
    L = ['%s=%r' % (key, value)
22980 
      for key, value in self.__dict__.iteritems()]
22981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22982 
 
22983 
  def __eq__(self, other):
22984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22985 
 
22986 
  def __ne__(self, other):
22987 
    return not (self == other)
22988 
 
22989 
class addCartEvent_result:
22990 
 
22991 
  thrift_spec = (
22992 
  )
22993 
 
22994 
  def read(self, iprot):
22995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22997 
      return
22998 
    iprot.readStructBegin()
22999 
    while True:
23000 
      (fname, ftype, fid) = iprot.readFieldBegin()
23001 
      if ftype == TType.STOP:
23002 
        break
23003 
      else:
23004 
        iprot.skip(ftype)
23005 
      iprot.readFieldEnd()
23006 
    iprot.readStructEnd()
23007 
 
23008 
  def write(self, oprot):
23009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23011 
      return
23012 
    oprot.writeStructBegin('addCartEvent_result')
23013 
    oprot.writeFieldStop()
23014 
    oprot.writeStructEnd()
23015 
 
23016 
  def validate(self):
23017 
    return
23018 
 
23019 
 
23020 
  def __repr__(self):
23021 
    L = ['%s=%r' % (key, value)
23022 
      for key, value in self.__dict__.iteritems()]
23023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23024 
 
23025 
  def __eq__(self, other):
23026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23027 
 
23028 
  def __ne__(self, other):
23029 
    return not (self == other)
8139 kshitij.so 23030 
 
8182 amar.kumar 23031 
class addEbayItem_args:
23032 
  """
23033 
  Attributes:
23034 
   - ebayItem
23035 
  """
23036 
 
23037 
  thrift_spec = (
23038 
    None, # 0
23039 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
23040 
  )
23041 
 
23042 
  def __init__(self, ebayItem=None,):
23043 
    self.ebayItem = ebayItem
23044 
 
23045 
  def read(self, iprot):
23046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23048 
      return
23049 
    iprot.readStructBegin()
23050 
    while True:
23051 
      (fname, ftype, fid) = iprot.readFieldBegin()
23052 
      if ftype == TType.STOP:
23053 
        break
23054 
      if fid == 1:
23055 
        if ftype == TType.STRUCT:
23056 
          self.ebayItem = EbayItem()
23057 
          self.ebayItem.read(iprot)
23058 
        else:
23059 
          iprot.skip(ftype)
23060 
      else:
23061 
        iprot.skip(ftype)
23062 
      iprot.readFieldEnd()
23063 
    iprot.readStructEnd()
23064 
 
23065 
  def write(self, oprot):
23066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23068 
      return
23069 
    oprot.writeStructBegin('addEbayItem_args')
23070 
    if self.ebayItem is not None:
23071 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
23072 
      self.ebayItem.write(oprot)
23073 
      oprot.writeFieldEnd()
23074 
    oprot.writeFieldStop()
23075 
    oprot.writeStructEnd()
23076 
 
23077 
  def validate(self):
23078 
    return
23079 
 
23080 
 
23081 
  def __repr__(self):
23082 
    L = ['%s=%r' % (key, value)
23083 
      for key, value in self.__dict__.iteritems()]
23084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23085 
 
23086 
  def __eq__(self, other):
23087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23088 
 
23089 
  def __ne__(self, other):
23090 
    return not (self == other)
23091 
 
23092 
class addEbayItem_result:
23093 
 
23094 
  thrift_spec = (
23095 
  )
23096 
 
23097 
  def read(self, iprot):
23098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23100 
      return
23101 
    iprot.readStructBegin()
23102 
    while True:
23103 
      (fname, ftype, fid) = iprot.readFieldBegin()
23104 
      if ftype == TType.STOP:
23105 
        break
23106 
      else:
23107 
        iprot.skip(ftype)
23108 
      iprot.readFieldEnd()
23109 
    iprot.readStructEnd()
23110 
 
23111 
  def write(self, oprot):
23112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23114 
      return
23115 
    oprot.writeStructBegin('addEbayItem_result')
23116 
    oprot.writeFieldStop()
23117 
    oprot.writeStructEnd()
23118 
 
23119 
  def validate(self):
23120 
    return
23121 
 
23122 
 
23123 
  def __repr__(self):
23124 
    L = ['%s=%r' % (key, value)
23125 
      for key, value in self.__dict__.iteritems()]
23126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23127 
 
23128 
  def __eq__(self, other):
23129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23130 
 
23131 
  def __ne__(self, other):
23132 
    return not (self == other)
23133 
 
23134 
class getEbayItem_args:
23135 
  """
23136 
  Attributes:
23137 
   - listingId
23138 
  """
23139 
 
23140 
  thrift_spec = (
23141 
    None, # 0
23142 
    (1, TType.STRING, 'listingId', None, None, ), # 1
23143 
  )
23144 
 
23145 
  def __init__(self, listingId=None,):
23146 
    self.listingId = listingId
23147 
 
23148 
  def read(self, iprot):
23149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23151 
      return
23152 
    iprot.readStructBegin()
23153 
    while True:
23154 
      (fname, ftype, fid) = iprot.readFieldBegin()
23155 
      if ftype == TType.STOP:
23156 
        break
23157 
      if fid == 1:
23158 
        if ftype == TType.STRING:
23159 
          self.listingId = iprot.readString();
23160 
        else:
23161 
          iprot.skip(ftype)
23162 
      else:
23163 
        iprot.skip(ftype)
23164 
      iprot.readFieldEnd()
23165 
    iprot.readStructEnd()
23166 
 
23167 
  def write(self, oprot):
23168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23170 
      return
23171 
    oprot.writeStructBegin('getEbayItem_args')
23172 
    if self.listingId is not None:
23173 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
23174 
      oprot.writeString(self.listingId)
23175 
      oprot.writeFieldEnd()
23176 
    oprot.writeFieldStop()
23177 
    oprot.writeStructEnd()
23178 
 
23179 
  def validate(self):
23180 
    return
23181 
 
23182 
 
23183 
  def __repr__(self):
23184 
    L = ['%s=%r' % (key, value)
23185 
      for key, value in self.__dict__.iteritems()]
23186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23187 
 
23188 
  def __eq__(self, other):
23189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23190 
 
23191 
  def __ne__(self, other):
23192 
    return not (self == other)
23193 
 
23194 
class getEbayItem_result:
23195 
  """
23196 
  Attributes:
23197 
   - success
23198 
  """
23199 
 
23200 
  thrift_spec = (
23201 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
23202 
  )
23203 
 
23204 
  def __init__(self, success=None,):
23205 
    self.success = success
23206 
 
23207 
  def read(self, iprot):
23208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23210 
      return
23211 
    iprot.readStructBegin()
23212 
    while True:
23213 
      (fname, ftype, fid) = iprot.readFieldBegin()
23214 
      if ftype == TType.STOP:
23215 
        break
23216 
      if fid == 0:
23217 
        if ftype == TType.STRUCT:
23218 
          self.success = EbayItem()
23219 
          self.success.read(iprot)
23220 
        else:
23221 
          iprot.skip(ftype)
23222 
      else:
23223 
        iprot.skip(ftype)
23224 
      iprot.readFieldEnd()
23225 
    iprot.readStructEnd()
23226 
 
23227 
  def write(self, oprot):
23228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23230 
      return
23231 
    oprot.writeStructBegin('getEbayItem_result')
23232 
    if self.success is not None:
23233 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23234 
      self.success.write(oprot)
23235 
      oprot.writeFieldEnd()
23236 
    oprot.writeFieldStop()
23237 
    oprot.writeStructEnd()
23238 
 
23239 
  def validate(self):
23240 
    return
23241 
 
23242 
 
23243 
  def __repr__(self):
23244 
    L = ['%s=%r' % (key, value)
23245 
      for key, value in self.__dict__.iteritems()]
23246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23247 
 
23248 
  def __eq__(self, other):
23249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23250 
 
23251 
  def __ne__(self, other):
23252 
    return not (self == other)
23253 
 
23254 
class updateEbayItem_args:
23255 
  """
23256 
  Attributes:
23257 
   - ebayItem
23258 
  """
23259 
 
23260 
  thrift_spec = (
23261 
    None, # 0
23262 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
23263 
  )
23264 
 
23265 
  def __init__(self, ebayItem=None,):
23266 
    self.ebayItem = ebayItem
23267 
 
23268 
  def read(self, iprot):
23269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23271 
      return
23272 
    iprot.readStructBegin()
23273 
    while True:
23274 
      (fname, ftype, fid) = iprot.readFieldBegin()
23275 
      if ftype == TType.STOP:
23276 
        break
23277 
      if fid == 1:
23278 
        if ftype == TType.STRUCT:
23279 
          self.ebayItem = EbayItem()
23280 
          self.ebayItem.read(iprot)
23281 
        else:
23282 
          iprot.skip(ftype)
23283 
      else:
23284 
        iprot.skip(ftype)
23285 
      iprot.readFieldEnd()
23286 
    iprot.readStructEnd()
23287 
 
23288 
  def write(self, oprot):
23289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23291 
      return
23292 
    oprot.writeStructBegin('updateEbayItem_args')
23293 
    if self.ebayItem is not None:
23294 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
23295 
      self.ebayItem.write(oprot)
23296 
      oprot.writeFieldEnd()
23297 
    oprot.writeFieldStop()
23298 
    oprot.writeStructEnd()
23299 
 
23300 
  def validate(self):
23301 
    return
23302 
 
23303 
 
23304 
  def __repr__(self):
23305 
    L = ['%s=%r' % (key, value)
23306 
      for key, value in self.__dict__.iteritems()]
23307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23308 
 
23309 
  def __eq__(self, other):
23310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23311 
 
23312 
  def __ne__(self, other):
23313 
    return not (self == other)
23314 
 
23315 
class updateEbayItem_result:
23316 
 
23317 
  thrift_spec = (
23318 
  )
23319 
 
23320 
  def read(self, iprot):
23321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23323 
      return
23324 
    iprot.readStructBegin()
23325 
    while True:
23326 
      (fname, ftype, fid) = iprot.readFieldBegin()
23327 
      if ftype == TType.STOP:
23328 
        break
23329 
      else:
23330 
        iprot.skip(ftype)
23331 
      iprot.readFieldEnd()
23332 
    iprot.readStructEnd()
23333 
 
23334 
  def write(self, oprot):
23335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23337 
      return
23338 
    oprot.writeStructBegin('updateEbayItem_result')
23339 
    oprot.writeFieldStop()
23340 
    oprot.writeStructEnd()
23341 
 
23342 
  def validate(self):
23343 
    return
23344 
 
23345 
 
23346 
  def __repr__(self):
23347 
    L = ['%s=%r' % (key, value)
23348 
      for key, value in self.__dict__.iteritems()]
23349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23350 
 
23351 
  def __eq__(self, other):
23352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23353 
 
23354 
  def __ne__(self, other):
23355 
    return not (self == other)
23356 
 
8139 kshitij.so 23357 
class getAmazonListedItems_args:
23358 
  """
23359 
  Attributes:
23360 
   - offset
23361 
   - limit
23362 
  """
23363 
 
23364 
  thrift_spec = (
23365 
    None, # 0
23366 
    (1, TType.I64, 'offset', None, None, ), # 1
23367 
    (2, TType.I64, 'limit', None, None, ), # 2
23368 
  )
23369 
 
23370 
  def __init__(self, offset=None, limit=None,):
23371 
    self.offset = offset
23372 
    self.limit = limit
23373 
 
23374 
  def read(self, iprot):
23375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23377 
      return
23378 
    iprot.readStructBegin()
23379 
    while True:
23380 
      (fname, ftype, fid) = iprot.readFieldBegin()
23381 
      if ftype == TType.STOP:
23382 
        break
23383 
      if fid == 1:
23384 
        if ftype == TType.I64:
23385 
          self.offset = iprot.readI64();
23386 
        else:
23387 
          iprot.skip(ftype)
23388 
      elif fid == 2:
23389 
        if ftype == TType.I64:
23390 
          self.limit = iprot.readI64();
23391 
        else:
23392 
          iprot.skip(ftype)
23393 
      else:
23394 
        iprot.skip(ftype)
23395 
      iprot.readFieldEnd()
23396 
    iprot.readStructEnd()
23397 
 
23398 
  def write(self, oprot):
23399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23401 
      return
23402 
    oprot.writeStructBegin('getAmazonListedItems_args')
23403 
    if self.offset is not None:
23404 
      oprot.writeFieldBegin('offset', TType.I64, 1)
23405 
      oprot.writeI64(self.offset)
23406 
      oprot.writeFieldEnd()
23407 
    if self.limit is not None:
23408 
      oprot.writeFieldBegin('limit', TType.I64, 2)
23409 
      oprot.writeI64(self.limit)
23410 
      oprot.writeFieldEnd()
23411 
    oprot.writeFieldStop()
23412 
    oprot.writeStructEnd()
23413 
 
23414 
  def validate(self):
23415 
    return
23416 
 
23417 
 
23418 
  def __repr__(self):
23419 
    L = ['%s=%r' % (key, value)
23420 
      for key, value in self.__dict__.iteritems()]
23421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23422 
 
23423 
  def __eq__(self, other):
23424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23425 
 
23426 
  def __ne__(self, other):
23427 
    return not (self == other)
23428 
 
23429 
class getAmazonListedItems_result:
23430 
  """
23431 
  Attributes:
23432 
   - success
23433 
  """
23434 
 
23435 
  thrift_spec = (
23436 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23437 
  )
23438 
 
23439 
  def __init__(self, success=None,):
23440 
    self.success = success
23441 
 
23442 
  def read(self, iprot):
23443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23445 
      return
23446 
    iprot.readStructBegin()
23447 
    while True:
23448 
      (fname, ftype, fid) = iprot.readFieldBegin()
23449 
      if ftype == TType.STOP:
23450 
        break
23451 
      if fid == 0:
23452 
        if ftype == TType.LIST:
23453 
          self.success = []
9155 kshitij.so 23454 
          (_etype477, _size474) = iprot.readListBegin()
23455 
          for _i478 in xrange(_size474):
23456 
            _elem479 = Amazonlisted()
23457 
            _elem479.read(iprot)
23458 
            self.success.append(_elem479)
8139 kshitij.so 23459 
          iprot.readListEnd()
23460 
        else:
23461 
          iprot.skip(ftype)
23462 
      else:
23463 
        iprot.skip(ftype)
23464 
      iprot.readFieldEnd()
23465 
    iprot.readStructEnd()
23466 
 
23467 
  def write(self, oprot):
23468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23470 
      return
23471 
    oprot.writeStructBegin('getAmazonListedItems_result')
23472 
    if self.success is not None:
23473 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23474 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23475 
      for iter480 in self.success:
23476 
        iter480.write(oprot)
8139 kshitij.so 23477 
      oprot.writeListEnd()
23478 
      oprot.writeFieldEnd()
23479 
    oprot.writeFieldStop()
23480 
    oprot.writeStructEnd()
23481 
 
23482 
  def validate(self):
23483 
    return
23484 
 
23485 
 
23486 
  def __repr__(self):
23487 
    L = ['%s=%r' % (key, value)
23488 
      for key, value in self.__dict__.iteritems()]
23489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23490 
 
23491 
  def __eq__(self, other):
23492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23493 
 
23494 
  def __ne__(self, other):
23495 
    return not (self == other)
8168 kshitij.so 23496 
 
23497 
class updateAmazonAttributesInBulk_args:
23498 
  """
23499 
  Attributes:
23500 
   - amazonlisted
23501 
  """
23502 
 
23503 
  thrift_spec = (
23504 
    None, # 0
23505 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
23506 
  )
23507 
 
23508 
  def __init__(self, amazonlisted=None,):
23509 
    self.amazonlisted = amazonlisted
23510 
 
23511 
  def read(self, iprot):
23512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23514 
      return
23515 
    iprot.readStructBegin()
23516 
    while True:
23517 
      (fname, ftype, fid) = iprot.readFieldBegin()
23518 
      if ftype == TType.STOP:
23519 
        break
23520 
      if fid == 1:
23521 
        if ftype == TType.MAP:
23522 
          self.amazonlisted = {}
9155 kshitij.so 23523 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
23524 
          for _i485 in xrange(_size481):
23525 
            _key486 = iprot.readI64();
23526 
            _val487 = Amazonlisted()
23527 
            _val487.read(iprot)
23528 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 23529 
          iprot.readMapEnd()
23530 
        else:
23531 
          iprot.skip(ftype)
23532 
      else:
23533 
        iprot.skip(ftype)
23534 
      iprot.readFieldEnd()
23535 
    iprot.readStructEnd()
23536 
 
23537 
  def write(self, oprot):
23538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23540 
      return
23541 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
23542 
    if self.amazonlisted is not None:
23543 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
23544 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 23545 
      for kiter488,viter489 in self.amazonlisted.items():
23546 
        oprot.writeI64(kiter488)
23547 
        viter489.write(oprot)
8168 kshitij.so 23548 
      oprot.writeMapEnd()
23549 
      oprot.writeFieldEnd()
23550 
    oprot.writeFieldStop()
23551 
    oprot.writeStructEnd()
23552 
 
23553 
  def validate(self):
23554 
    return
23555 
 
23556 
 
23557 
  def __repr__(self):
23558 
    L = ['%s=%r' % (key, value)
23559 
      for key, value in self.__dict__.iteritems()]
23560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23561 
 
23562 
  def __eq__(self, other):
23563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23564 
 
23565 
  def __ne__(self, other):
23566 
    return not (self == other)
23567 
 
23568 
class updateAmazonAttributesInBulk_result:
23569 
  """
23570 
  Attributes:
23571 
   - success
23572 
  """
23573 
 
23574 
  thrift_spec = (
23575 
    (0, TType.BOOL, 'success', None, None, ), # 0
23576 
  )
23577 
 
23578 
  def __init__(self, success=None,):
23579 
    self.success = success
23580 
 
23581 
  def read(self, iprot):
23582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23584 
      return
23585 
    iprot.readStructBegin()
23586 
    while True:
23587 
      (fname, ftype, fid) = iprot.readFieldBegin()
23588 
      if ftype == TType.STOP:
23589 
        break
23590 
      if fid == 0:
23591 
        if ftype == TType.BOOL:
23592 
          self.success = iprot.readBool();
23593 
        else:
23594 
          iprot.skip(ftype)
23595 
      else:
23596 
        iprot.skip(ftype)
23597 
      iprot.readFieldEnd()
23598 
    iprot.readStructEnd()
23599 
 
23600 
  def write(self, oprot):
23601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23603 
      return
23604 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
23605 
    if self.success is not None:
23606 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23607 
      oprot.writeBool(self.success)
23608 
      oprot.writeFieldEnd()
23609 
    oprot.writeFieldStop()
23610 
    oprot.writeStructEnd()
23611 
 
23612 
  def validate(self):
23613 
    return
23614 
 
23615 
 
23616 
  def __repr__(self):
23617 
    L = ['%s=%r' % (key, value)
23618 
      for key, value in self.__dict__.iteritems()]
23619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23620 
 
23621 
  def __eq__(self, other):
23622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23623 
 
23624 
  def __ne__(self, other):
23625 
    return not (self == other)
8379 vikram.rag 23626 
 
23627 
class getAllItemstoListOnFba_args:
23628 
 
23629 
  thrift_spec = (
23630 
  )
23631 
 
23632 
  def read(self, iprot):
23633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23635 
      return
23636 
    iprot.readStructBegin()
23637 
    while True:
23638 
      (fname, ftype, fid) = iprot.readFieldBegin()
23639 
      if ftype == TType.STOP:
23640 
        break
23641 
      else:
23642 
        iprot.skip(ftype)
23643 
      iprot.readFieldEnd()
23644 
    iprot.readStructEnd()
23645 
 
23646 
  def write(self, oprot):
23647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23649 
      return
23650 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
23651 
    oprot.writeFieldStop()
23652 
    oprot.writeStructEnd()
23653 
 
23654 
  def validate(self):
23655 
    return
23656 
 
23657 
 
23658 
  def __repr__(self):
23659 
    L = ['%s=%r' % (key, value)
23660 
      for key, value in self.__dict__.iteritems()]
23661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23662 
 
23663 
  def __eq__(self, other):
23664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23665 
 
23666 
  def __ne__(self, other):
23667 
    return not (self == other)
23668 
 
23669 
class getAllItemstoListOnFba_result:
23670 
  """
23671 
  Attributes:
23672 
   - success
23673 
  """
23674 
 
23675 
  thrift_spec = (
23676 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23677 
  )
23678 
 
23679 
  def __init__(self, success=None,):
23680 
    self.success = success
23681 
 
23682 
  def read(self, iprot):
23683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23685 
      return
23686 
    iprot.readStructBegin()
23687 
    while True:
23688 
      (fname, ftype, fid) = iprot.readFieldBegin()
23689 
      if ftype == TType.STOP:
23690 
        break
23691 
      if fid == 0:
23692 
        if ftype == TType.LIST:
23693 
          self.success = []
9155 kshitij.so 23694 
          (_etype493, _size490) = iprot.readListBegin()
23695 
          for _i494 in xrange(_size490):
23696 
            _elem495 = Amazonlisted()
23697 
            _elem495.read(iprot)
23698 
            self.success.append(_elem495)
8379 vikram.rag 23699 
          iprot.readListEnd()
23700 
        else:
23701 
          iprot.skip(ftype)
23702 
      else:
23703 
        iprot.skip(ftype)
23704 
      iprot.readFieldEnd()
23705 
    iprot.readStructEnd()
23706 
 
23707 
  def write(self, oprot):
23708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23710 
      return
23711 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
23712 
    if self.success is not None:
23713 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23714 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23715 
      for iter496 in self.success:
23716 
        iter496.write(oprot)
8379 vikram.rag 23717 
      oprot.writeListEnd()
23718 
      oprot.writeFieldEnd()
23719 
    oprot.writeFieldStop()
23720 
    oprot.writeStructEnd()
23721 
 
23722 
  def validate(self):
23723 
    return
23724 
 
23725 
 
23726 
  def __repr__(self):
23727 
    L = ['%s=%r' % (key, value)
23728 
      for key, value in self.__dict__.iteritems()]
23729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23730 
 
23731 
  def __eq__(self, other):
23732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23733 
 
23734 
  def __ne__(self, other):
23735 
    return not (self == other)
23736 
 
23737 
class getAllItemstoListOnNonFba_args:
23738 
 
23739 
  thrift_spec = (
23740 
  )
23741 
 
23742 
  def read(self, iprot):
23743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23745 
      return
23746 
    iprot.readStructBegin()
23747 
    while True:
23748 
      (fname, ftype, fid) = iprot.readFieldBegin()
23749 
      if ftype == TType.STOP:
23750 
        break
23751 
      else:
23752 
        iprot.skip(ftype)
23753 
      iprot.readFieldEnd()
23754 
    iprot.readStructEnd()
23755 
 
23756 
  def write(self, oprot):
23757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23759 
      return
23760 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
23761 
    oprot.writeFieldStop()
23762 
    oprot.writeStructEnd()
23763 
 
23764 
  def validate(self):
23765 
    return
23766 
 
23767 
 
23768 
  def __repr__(self):
23769 
    L = ['%s=%r' % (key, value)
23770 
      for key, value in self.__dict__.iteritems()]
23771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23772 
 
23773 
  def __eq__(self, other):
23774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23775 
 
23776 
  def __ne__(self, other):
23777 
    return not (self == other)
23778 
 
23779 
class getAllItemstoListOnNonFba_result:
23780 
  """
23781 
  Attributes:
23782 
   - success
23783 
  """
23784 
 
23785 
  thrift_spec = (
23786 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23787 
  )
23788 
 
23789 
  def __init__(self, success=None,):
23790 
    self.success = success
23791 
 
23792 
  def read(self, iprot):
23793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23795 
      return
23796 
    iprot.readStructBegin()
23797 
    while True:
23798 
      (fname, ftype, fid) = iprot.readFieldBegin()
23799 
      if ftype == TType.STOP:
23800 
        break
23801 
      if fid == 0:
23802 
        if ftype == TType.LIST:
23803 
          self.success = []
9155 kshitij.so 23804 
          (_etype500, _size497) = iprot.readListBegin()
23805 
          for _i501 in xrange(_size497):
23806 
            _elem502 = Amazonlisted()
23807 
            _elem502.read(iprot)
23808 
            self.success.append(_elem502)
8379 vikram.rag 23809 
          iprot.readListEnd()
23810 
        else:
23811 
          iprot.skip(ftype)
23812 
      else:
23813 
        iprot.skip(ftype)
23814 
      iprot.readFieldEnd()
23815 
    iprot.readStructEnd()
23816 
 
23817 
  def write(self, oprot):
23818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23820 
      return
23821 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
23822 
    if self.success is not None:
23823 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23824 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23825 
      for iter503 in self.success:
23826 
        iter503.write(oprot)
8379 vikram.rag 23827 
      oprot.writeListEnd()
23828 
      oprot.writeFieldEnd()
23829 
    oprot.writeFieldStop()
23830 
    oprot.writeStructEnd()
23831 
 
23832 
  def validate(self):
23833 
    return
23834 
 
23835 
 
23836 
  def __repr__(self):
23837 
    L = ['%s=%r' % (key, value)
23838 
      for key, value in self.__dict__.iteritems()]
23839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23840 
 
23841 
  def __eq__(self, other):
23842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23843 
 
23844 
  def __ne__(self, other):
23845 
    return not (self == other)
8616 vikram.rag 23846 
 
9242 kshitij.so 23847 
class updateAsin_args:
23848 
  """
23849 
  Attributes:
23850 
   - item
23851 
  """
8616 vikram.rag 23852 
 
23853 
  thrift_spec = (
9242 kshitij.so 23854 
    None, # 0
23855 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 23856 
  )
23857 
 
9242 kshitij.so 23858 
  def __init__(self, item=None,):
23859 
    self.item = item
23860 
 
8616 vikram.rag 23861 
  def read(self, iprot):
23862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23864 
      return
23865 
    iprot.readStructBegin()
23866 
    while True:
23867 
      (fname, ftype, fid) = iprot.readFieldBegin()
23868 
      if ftype == TType.STOP:
23869 
        break
9242 kshitij.so 23870 
      if fid == 1:
23871 
        if ftype == TType.MAP:
23872 
          self.item = {}
23873 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
23874 
          for _i508 in xrange(_size504):
23875 
            _key509 = iprot.readI64();
23876 
            _val510 = Item()
23877 
            _val510.read(iprot)
23878 
            self.item[_key509] = _val510
23879 
          iprot.readMapEnd()
23880 
        else:
23881 
          iprot.skip(ftype)
8616 vikram.rag 23882 
      else:
23883 
        iprot.skip(ftype)
23884 
      iprot.readFieldEnd()
23885 
    iprot.readStructEnd()
23886 
 
23887 
  def write(self, oprot):
23888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23890 
      return
9242 kshitij.so 23891 
    oprot.writeStructBegin('updateAsin_args')
23892 
    if self.item is not None:
23893 
      oprot.writeFieldBegin('item', TType.MAP, 1)
23894 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
23895 
      for kiter511,viter512 in self.item.items():
23896 
        oprot.writeI64(kiter511)
23897 
        viter512.write(oprot)
23898 
      oprot.writeMapEnd()
23899 
      oprot.writeFieldEnd()
8616 vikram.rag 23900 
    oprot.writeFieldStop()
23901 
    oprot.writeStructEnd()
23902 
 
23903 
  def validate(self):
23904 
    return
23905 
 
23906 
 
23907 
  def __repr__(self):
23908 
    L = ['%s=%r' % (key, value)
23909 
      for key, value in self.__dict__.iteritems()]
23910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23911 
 
23912 
  def __eq__(self, other):
23913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23914 
 
23915 
  def __ne__(self, other):
23916 
    return not (self == other)
23917 
 
9242 kshitij.so 23918 
class updateAsin_result:
8616 vikram.rag 23919 
 
23920 
  thrift_spec = (
23921 
  )
23922 
 
23923 
  def read(self, iprot):
23924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23926 
      return
23927 
    iprot.readStructBegin()
23928 
    while True:
23929 
      (fname, ftype, fid) = iprot.readFieldBegin()
23930 
      if ftype == TType.STOP:
23931 
        break
23932 
      else:
23933 
        iprot.skip(ftype)
23934 
      iprot.readFieldEnd()
23935 
    iprot.readStructEnd()
23936 
 
23937 
  def write(self, oprot):
23938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23940 
      return
9242 kshitij.so 23941 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 23942 
    oprot.writeFieldStop()
23943 
    oprot.writeStructEnd()
23944 
 
23945 
  def validate(self):
23946 
    return
23947 
 
23948 
 
23949 
  def __repr__(self):
23950 
    L = ['%s=%r' % (key, value)
23951 
      for key, value in self.__dict__.iteritems()]
23952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23953 
 
23954 
  def __eq__(self, other):
23955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23956 
 
23957 
  def __ne__(self, other):
23958 
    return not (self == other)
8619 kshitij.so 23959 
 
9242 kshitij.so 23960 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 23961 
  """
23962 
  Attributes:
9242 kshitij.so 23963 
   - snapdealitem
8619 kshitij.so 23964 
  """
23965 
 
9242 kshitij.so 23966 
  thrift_spec = None
23967 
  def __init__(self, snapdealitem=None,):
23968 
    self.snapdealitem = snapdealitem
8619 kshitij.so 23969 
 
23970 
  def read(self, iprot):
23971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23973 
      return
23974 
    iprot.readStructBegin()
23975 
    while True:
23976 
      (fname, ftype, fid) = iprot.readFieldBegin()
23977 
      if ftype == TType.STOP:
23978 
        break
9242 kshitij.so 23979 
      if fid == -1:
23980 
        if ftype == TType.STRUCT:
23981 
          self.snapdealitem = SnapdealItem()
23982 
          self.snapdealitem.read(iprot)
8619 kshitij.so 23983 
        else:
23984 
          iprot.skip(ftype)
23985 
      else:
23986 
        iprot.skip(ftype)
23987 
      iprot.readFieldEnd()
23988 
    iprot.readStructEnd()
23989 
 
23990 
  def write(self, oprot):
23991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23993 
      return
9242 kshitij.so 23994 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
23995 
    if self.snapdealitem is not None:
23996 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
23997 
      self.snapdealitem.write(oprot)
8619 kshitij.so 23998 
      oprot.writeFieldEnd()
23999 
    oprot.writeFieldStop()
24000 
    oprot.writeStructEnd()
24001 
 
24002 
  def validate(self):
24003 
    return
24004 
 
24005 
 
24006 
  def __repr__(self):
24007 
    L = ['%s=%r' % (key, value)
24008 
      for key, value in self.__dict__.iteritems()]
24009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24010 
 
24011 
  def __eq__(self, other):
24012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24013 
 
24014 
  def __ne__(self, other):
24015 
    return not (self == other)
24016 
 
9242 kshitij.so 24017 
class addOrUpdateSnapdealItem_result:
24018 
  """
24019 
  Attributes:
24020 
   - success
24021 
  """
8619 kshitij.so 24022 
 
24023 
  thrift_spec = (
9242 kshitij.so 24024 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 24025 
  )
24026 
 
9242 kshitij.so 24027 
  def __init__(self, success=None,):
24028 
    self.success = success
24029 
 
8619 kshitij.so 24030 
  def read(self, iprot):
24031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24033 
      return
24034 
    iprot.readStructBegin()
24035 
    while True:
24036 
      (fname, ftype, fid) = iprot.readFieldBegin()
24037 
      if ftype == TType.STOP:
24038 
        break
9242 kshitij.so 24039 
      if fid == 0:
24040 
        if ftype == TType.BOOL:
24041 
          self.success = iprot.readBool();
24042 
        else:
24043 
          iprot.skip(ftype)
8619 kshitij.so 24044 
      else:
24045 
        iprot.skip(ftype)
24046 
      iprot.readFieldEnd()
24047 
    iprot.readStructEnd()
24048 
 
24049 
  def write(self, oprot):
24050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24052 
      return
9242 kshitij.so 24053 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
24054 
    if self.success is not None:
24055 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24056 
      oprot.writeBool(self.success)
24057 
      oprot.writeFieldEnd()
8619 kshitij.so 24058 
    oprot.writeFieldStop()
24059 
    oprot.writeStructEnd()
24060 
 
24061 
  def validate(self):
24062 
    return
24063 
 
24064 
 
24065 
  def __repr__(self):
24066 
    L = ['%s=%r' % (key, value)
24067 
      for key, value in self.__dict__.iteritems()]
24068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24069 
 
24070 
  def __eq__(self, other):
24071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24072 
 
24073 
  def __ne__(self, other):
24074 
    return not (self == other)
8739 vikram.rag 24075 
 
9242 kshitij.so 24076 
class getSnapdealItem_args:
8739 vikram.rag 24077 
  """
24078 
  Attributes:
9242 kshitij.so 24079 
   - item_id
8739 vikram.rag 24080 
  """
24081 
 
9242 kshitij.so 24082 
  thrift_spec = (
24083 
    None, # 0
24084 
    (1, TType.I64, 'item_id', None, None, ), # 1
24085 
  )
8739 vikram.rag 24086 
 
9242 kshitij.so 24087 
  def __init__(self, item_id=None,):
24088 
    self.item_id = item_id
24089 
 
8739 vikram.rag 24090 
  def read(self, iprot):
24091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24093 
      return
24094 
    iprot.readStructBegin()
24095 
    while True:
24096 
      (fname, ftype, fid) = iprot.readFieldBegin()
24097 
      if ftype == TType.STOP:
24098 
        break
9242 kshitij.so 24099 
      if fid == 1:
24100 
        if ftype == TType.I64:
24101 
          self.item_id = iprot.readI64();
8739 vikram.rag 24102 
        else:
24103 
          iprot.skip(ftype)
24104 
      else:
24105 
        iprot.skip(ftype)
24106 
      iprot.readFieldEnd()
24107 
    iprot.readStructEnd()
24108 
 
24109 
  def write(self, oprot):
24110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24112 
      return
9242 kshitij.so 24113 
    oprot.writeStructBegin('getSnapdealItem_args')
24114 
    if self.item_id is not None:
24115 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
24116 
      oprot.writeI64(self.item_id)
8739 vikram.rag 24117 
      oprot.writeFieldEnd()
24118 
    oprot.writeFieldStop()
24119 
    oprot.writeStructEnd()
24120 
 
24121 
  def validate(self):
24122 
    return
24123 
 
24124 
 
24125 
  def __repr__(self):
24126 
    L = ['%s=%r' % (key, value)
24127 
      for key, value in self.__dict__.iteritems()]
24128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24129 
 
24130 
  def __eq__(self, other):
24131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24132 
 
24133 
  def __ne__(self, other):
24134 
    return not (self == other)
24135 
 
9242 kshitij.so 24136 
class getSnapdealItem_result:
8739 vikram.rag 24137 
  """
24138 
  Attributes:
24139 
   - success
24140 
  """
24141 
 
24142 
  thrift_spec = (
9242 kshitij.so 24143 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 24144 
  )
24145 
 
24146 
  def __init__(self, success=None,):
24147 
    self.success = success
24148 
 
24149 
  def read(self, iprot):
24150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24152 
      return
24153 
    iprot.readStructBegin()
24154 
    while True:
24155 
      (fname, ftype, fid) = iprot.readFieldBegin()
24156 
      if ftype == TType.STOP:
24157 
        break
24158 
      if fid == 0:
9242 kshitij.so 24159 
        if ftype == TType.STRUCT:
24160 
          self.success = SnapdealItem()
24161 
          self.success.read(iprot)
8739 vikram.rag 24162 
        else:
24163 
          iprot.skip(ftype)
24164 
      else:
24165 
        iprot.skip(ftype)
24166 
      iprot.readFieldEnd()
24167 
    iprot.readStructEnd()
24168 
 
24169 
  def write(self, oprot):
24170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24172 
      return
9242 kshitij.so 24173 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 24174 
    if self.success is not None:
9242 kshitij.so 24175 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24176 
      self.success.write(oprot)
8739 vikram.rag 24177 
      oprot.writeFieldEnd()
24178 
    oprot.writeFieldStop()
24179 
    oprot.writeStructEnd()
24180 
 
24181 
  def validate(self):
24182 
    return
24183 
 
24184 
 
24185 
  def __repr__(self):
24186 
    L = ['%s=%r' % (key, value)
24187 
      for key, value in self.__dict__.iteritems()]
24188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24189 
 
24190 
  def __eq__(self, other):
24191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24192 
 
24193 
  def __ne__(self, other):
24194 
    return not (self == other)
24195 
 
9242 kshitij.so 24196 
class getSnapdealItemDetails_args:
8739 vikram.rag 24197 
  """
24198 
  Attributes:
24199 
   - item_id
24200 
  """
24201 
 
24202 
  thrift_spec = (
24203 
    None, # 0
24204 
    (1, TType.I64, 'item_id', None, None, ), # 1
24205 
  )
24206 
 
24207 
  def __init__(self, item_id=None,):
24208 
    self.item_id = item_id
24209 
 
24210 
  def read(self, iprot):
24211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24213 
      return
24214 
    iprot.readStructBegin()
24215 
    while True:
24216 
      (fname, ftype, fid) = iprot.readFieldBegin()
24217 
      if ftype == TType.STOP:
24218 
        break
24219 
      if fid == 1:
24220 
        if ftype == TType.I64:
24221 
          self.item_id = iprot.readI64();
24222 
        else:
24223 
          iprot.skip(ftype)
24224 
      else:
24225 
        iprot.skip(ftype)
24226 
      iprot.readFieldEnd()
24227 
    iprot.readStructEnd()
24228 
 
24229 
  def write(self, oprot):
24230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24232 
      return
9242 kshitij.so 24233 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 24234 
    if self.item_id is not None:
24235 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
24236 
      oprot.writeI64(self.item_id)
24237 
      oprot.writeFieldEnd()
24238 
    oprot.writeFieldStop()
24239 
    oprot.writeStructEnd()
24240 
 
24241 
  def validate(self):
24242 
    return
24243 
 
24244 
 
24245 
  def __repr__(self):
24246 
    L = ['%s=%r' % (key, value)
24247 
      for key, value in self.__dict__.iteritems()]
24248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24249 
 
24250 
  def __eq__(self, other):
24251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24252 
 
24253 
  def __ne__(self, other):
24254 
    return not (self == other)
24255 
 
9242 kshitij.so 24256 
class getSnapdealItemDetails_result:
8739 vikram.rag 24257 
  """
24258 
  Attributes:
24259 
   - success
24260 
  """
24261 
 
24262 
  thrift_spec = (
9242 kshitij.so 24263 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 24264 
  )
24265 
 
24266 
  def __init__(self, success=None,):
24267 
    self.success = success
24268 
 
24269 
  def read(self, iprot):
24270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24272 
      return
24273 
    iprot.readStructBegin()
24274 
    while True:
24275 
      (fname, ftype, fid) = iprot.readFieldBegin()
24276 
      if ftype == TType.STOP:
24277 
        break
24278 
      if fid == 0:
24279 
        if ftype == TType.STRUCT:
9242 kshitij.so 24280 
          self.success = SnapdealItemDetails()
8739 vikram.rag 24281 
          self.success.read(iprot)
24282 
        else:
24283 
          iprot.skip(ftype)
24284 
      else:
24285 
        iprot.skip(ftype)
24286 
      iprot.readFieldEnd()
24287 
    iprot.readStructEnd()
24288 
 
24289 
  def write(self, oprot):
24290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24292 
      return
9242 kshitij.so 24293 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 24294 
    if self.success is not None:
24295 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24296 
      self.success.write(oprot)
24297 
      oprot.writeFieldEnd()
24298 
    oprot.writeFieldStop()
24299 
    oprot.writeStructEnd()
24300 
 
24301 
  def validate(self):
24302 
    return
24303 
 
24304 
 
24305 
  def __repr__(self):
24306 
    L = ['%s=%r' % (key, value)
24307 
      for key, value in self.__dict__.iteritems()]
24308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24309 
 
24310 
  def __eq__(self, other):
24311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24312 
 
24313 
  def __ne__(self, other):
24314 
    return not (self == other)
24315 
 
24316 
class getAllSnapdealItems_args:
24317 
 
24318 
  thrift_spec = (
24319 
  )
24320 
 
24321 
  def read(self, iprot):
24322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24324 
      return
24325 
    iprot.readStructBegin()
24326 
    while True:
24327 
      (fname, ftype, fid) = iprot.readFieldBegin()
24328 
      if ftype == TType.STOP:
24329 
        break
24330 
      else:
24331 
        iprot.skip(ftype)
24332 
      iprot.readFieldEnd()
24333 
    iprot.readStructEnd()
24334 
 
24335 
  def write(self, oprot):
24336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24338 
      return
24339 
    oprot.writeStructBegin('getAllSnapdealItems_args')
24340 
    oprot.writeFieldStop()
24341 
    oprot.writeStructEnd()
24342 
 
24343 
  def validate(self):
24344 
    return
24345 
 
24346 
 
24347 
  def __repr__(self):
24348 
    L = ['%s=%r' % (key, value)
24349 
      for key, value in self.__dict__.iteritems()]
24350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24351 
 
24352 
  def __eq__(self, other):
24353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24354 
 
24355 
  def __ne__(self, other):
24356 
    return not (self == other)
24357 
 
24358 
class getAllSnapdealItems_result:
24359 
  """
24360 
  Attributes:
24361 
   - success
24362 
  """
24363 
 
24364 
  thrift_spec = (
9242 kshitij.so 24365 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 24366 
  )
24367 
 
24368 
  def __init__(self, success=None,):
24369 
    self.success = success
24370 
 
24371 
  def read(self, iprot):
24372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24374 
      return
24375 
    iprot.readStructBegin()
24376 
    while True:
24377 
      (fname, ftype, fid) = iprot.readFieldBegin()
24378 
      if ftype == TType.STOP:
24379 
        break
24380 
      if fid == 0:
24381 
        if ftype == TType.LIST:
24382 
          self.success = []
9242 kshitij.so 24383 
          (_etype516, _size513) = iprot.readListBegin()
24384 
          for _i517 in xrange(_size513):
24385 
            _elem518 = SnapdealItemDetails()
24386 
            _elem518.read(iprot)
24387 
            self.success.append(_elem518)
24388 
          iprot.readListEnd()
24389 
        else:
24390 
          iprot.skip(ftype)
24391 
      else:
24392 
        iprot.skip(ftype)
24393 
      iprot.readFieldEnd()
24394 
    iprot.readStructEnd()
24395 
 
24396 
  def write(self, oprot):
24397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24399 
      return
24400 
    oprot.writeStructBegin('getAllSnapdealItems_result')
24401 
    if self.success is not None:
24402 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24403 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24404 
      for iter519 in self.success:
24405 
        iter519.write(oprot)
24406 
      oprot.writeListEnd()
24407 
      oprot.writeFieldEnd()
24408 
    oprot.writeFieldStop()
24409 
    oprot.writeStructEnd()
24410 
 
24411 
  def validate(self):
24412 
    return
24413 
 
24414 
 
24415 
  def __repr__(self):
24416 
    L = ['%s=%r' % (key, value)
24417 
      for key, value in self.__dict__.iteritems()]
24418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24419 
 
24420 
  def __eq__(self, other):
24421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24422 
 
24423 
  def __ne__(self, other):
24424 
    return not (self == other)
24425 
 
24426 
class getSnapdealItems_args:
24427 
  """
24428 
  Attributes:
24429 
   - offset
24430 
   - limit
24431 
  """
24432 
 
24433 
  thrift_spec = (
24434 
    None, # 0
24435 
    (1, TType.I64, 'offset', None, None, ), # 1
24436 
    (2, TType.I64, 'limit', None, None, ), # 2
24437 
  )
24438 
 
24439 
  def __init__(self, offset=None, limit=None,):
24440 
    self.offset = offset
24441 
    self.limit = limit
24442 
 
24443 
  def read(self, iprot):
24444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24446 
      return
24447 
    iprot.readStructBegin()
24448 
    while True:
24449 
      (fname, ftype, fid) = iprot.readFieldBegin()
24450 
      if ftype == TType.STOP:
24451 
        break
24452 
      if fid == 1:
24453 
        if ftype == TType.I64:
24454 
          self.offset = iprot.readI64();
24455 
        else:
24456 
          iprot.skip(ftype)
24457 
      elif fid == 2:
24458 
        if ftype == TType.I64:
24459 
          self.limit = iprot.readI64();
24460 
        else:
24461 
          iprot.skip(ftype)
24462 
      else:
24463 
        iprot.skip(ftype)
24464 
      iprot.readFieldEnd()
24465 
    iprot.readStructEnd()
24466 
 
24467 
  def write(self, oprot):
24468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24470 
      return
24471 
    oprot.writeStructBegin('getSnapdealItems_args')
24472 
    if self.offset is not None:
24473 
      oprot.writeFieldBegin('offset', TType.I64, 1)
24474 
      oprot.writeI64(self.offset)
24475 
      oprot.writeFieldEnd()
24476 
    if self.limit is not None:
24477 
      oprot.writeFieldBegin('limit', TType.I64, 2)
24478 
      oprot.writeI64(self.limit)
24479 
      oprot.writeFieldEnd()
24480 
    oprot.writeFieldStop()
24481 
    oprot.writeStructEnd()
24482 
 
24483 
  def validate(self):
24484 
    return
24485 
 
24486 
 
24487 
  def __repr__(self):
24488 
    L = ['%s=%r' % (key, value)
24489 
      for key, value in self.__dict__.iteritems()]
24490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24491 
 
24492 
  def __eq__(self, other):
24493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24494 
 
24495 
  def __ne__(self, other):
24496 
    return not (self == other)
24497 
 
24498 
class getSnapdealItems_result:
24499 
  """
24500 
  Attributes:
24501 
   - success
24502 
  """
24503 
 
24504 
  thrift_spec = (
24505 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
24506 
  )
24507 
 
24508 
  def __init__(self, success=None,):
24509 
    self.success = success
24510 
 
24511 
  def read(self, iprot):
24512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24514 
      return
24515 
    iprot.readStructBegin()
24516 
    while True:
24517 
      (fname, ftype, fid) = iprot.readFieldBegin()
24518 
      if ftype == TType.STOP:
24519 
        break
24520 
      if fid == 0:
24521 
        if ftype == TType.LIST:
24522 
          self.success = []
9155 kshitij.so 24523 
          (_etype523, _size520) = iprot.readListBegin()
24524 
          for _i524 in xrange(_size520):
9242 kshitij.so 24525 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 24526 
            _elem525.read(iprot)
24527 
            self.success.append(_elem525)
8739 vikram.rag 24528 
          iprot.readListEnd()
24529 
        else:
24530 
          iprot.skip(ftype)
24531 
      else:
24532 
        iprot.skip(ftype)
24533 
      iprot.readFieldEnd()
24534 
    iprot.readStructEnd()
24535 
 
24536 
  def write(self, oprot):
24537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24539 
      return
9242 kshitij.so 24540 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 24541 
    if self.success is not None:
24542 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24543 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 24544 
      for iter526 in self.success:
24545 
        iter526.write(oprot)
8739 vikram.rag 24546 
      oprot.writeListEnd()
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)
9242 kshitij.so 24565 
 
24566 
class searchSnapdealItems_args:
24567 
  """
24568 
  Attributes:
24569 
   - searchTerm
24570 
   - offset
24571 
   - limit
24572 
  """
24573 
 
24574 
  thrift_spec = (
24575 
    None, # 0
24576 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
24577 
    (2, TType.I64, 'offset', None, None, ), # 2
24578 
    (3, TType.I64, 'limit', None, None, ), # 3
24579 
  )
24580 
 
24581 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
24582 
    self.searchTerm = searchTerm
24583 
    self.offset = offset
24584 
    self.limit = limit
24585 
 
24586 
  def read(self, iprot):
24587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24589 
      return
24590 
    iprot.readStructBegin()
24591 
    while True:
24592 
      (fname, ftype, fid) = iprot.readFieldBegin()
24593 
      if ftype == TType.STOP:
24594 
        break
24595 
      if fid == 1:
24596 
        if ftype == TType.LIST:
24597 
          self.searchTerm = []
24598 
          (_etype530, _size527) = iprot.readListBegin()
24599 
          for _i531 in xrange(_size527):
24600 
            _elem532 = iprot.readString();
24601 
            self.searchTerm.append(_elem532)
24602 
          iprot.readListEnd()
24603 
        else:
24604 
          iprot.skip(ftype)
24605 
      elif fid == 2:
24606 
        if ftype == TType.I64:
24607 
          self.offset = iprot.readI64();
24608 
        else:
24609 
          iprot.skip(ftype)
24610 
      elif fid == 3:
24611 
        if ftype == TType.I64:
24612 
          self.limit = iprot.readI64();
24613 
        else:
24614 
          iprot.skip(ftype)
24615 
      else:
24616 
        iprot.skip(ftype)
24617 
      iprot.readFieldEnd()
24618 
    iprot.readStructEnd()
24619 
 
24620 
  def write(self, oprot):
24621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24623 
      return
24624 
    oprot.writeStructBegin('searchSnapdealItems_args')
24625 
    if self.searchTerm is not None:
24626 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
24627 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
24628 
      for iter533 in self.searchTerm:
24629 
        oprot.writeString(iter533)
24630 
      oprot.writeListEnd()
24631 
      oprot.writeFieldEnd()
24632 
    if self.offset is not None:
24633 
      oprot.writeFieldBegin('offset', TType.I64, 2)
24634 
      oprot.writeI64(self.offset)
24635 
      oprot.writeFieldEnd()
24636 
    if self.limit is not None:
24637 
      oprot.writeFieldBegin('limit', TType.I64, 3)
24638 
      oprot.writeI64(self.limit)
24639 
      oprot.writeFieldEnd()
24640 
    oprot.writeFieldStop()
24641 
    oprot.writeStructEnd()
24642 
 
24643 
  def validate(self):
24644 
    return
24645 
 
24646 
 
24647 
  def __repr__(self):
24648 
    L = ['%s=%r' % (key, value)
24649 
      for key, value in self.__dict__.iteritems()]
24650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24651 
 
24652 
  def __eq__(self, other):
24653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24654 
 
24655 
  def __ne__(self, other):
24656 
    return not (self == other)
24657 
 
24658 
class searchSnapdealItems_result:
24659 
  """
24660 
  Attributes:
24661 
   - success
24662 
  """
24663 
 
24664 
  thrift_spec = (
24665 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
24666 
  )
24667 
 
24668 
  def __init__(self, success=None,):
24669 
    self.success = success
24670 
 
24671 
  def read(self, iprot):
24672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24674 
      return
24675 
    iprot.readStructBegin()
24676 
    while True:
24677 
      (fname, ftype, fid) = iprot.readFieldBegin()
24678 
      if ftype == TType.STOP:
24679 
        break
24680 
      if fid == 0:
24681 
        if ftype == TType.LIST:
24682 
          self.success = []
24683 
          (_etype537, _size534) = iprot.readListBegin()
24684 
          for _i538 in xrange(_size534):
24685 
            _elem539 = SnapdealItemDetails()
24686 
            _elem539.read(iprot)
24687 
            self.success.append(_elem539)
24688 
          iprot.readListEnd()
24689 
        else:
24690 
          iprot.skip(ftype)
24691 
      else:
24692 
        iprot.skip(ftype)
24693 
      iprot.readFieldEnd()
24694 
    iprot.readStructEnd()
24695 
 
24696 
  def write(self, oprot):
24697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24699 
      return
24700 
    oprot.writeStructBegin('searchSnapdealItems_result')
24701 
    if self.success is not None:
24702 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24703 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24704 
      for iter540 in self.success:
24705 
        iter540.write(oprot)
24706 
      oprot.writeListEnd()
24707 
      oprot.writeFieldEnd()
24708 
    oprot.writeFieldStop()
24709 
    oprot.writeStructEnd()
24710 
 
24711 
  def validate(self):
24712 
    return
24713 
 
24714 
 
24715 
  def __repr__(self):
24716 
    L = ['%s=%r' % (key, value)
24717 
      for key, value in self.__dict__.iteritems()]
24718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24719 
 
24720 
  def __eq__(self, other):
24721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24722 
 
24723 
  def __ne__(self, other):
24724 
    return not (self == other)
24725 
 
24726 
class getCountForSnapdealItems_args:
24727 
 
24728 
  thrift_spec = (
24729 
  )
24730 
 
24731 
  def read(self, iprot):
24732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24734 
      return
24735 
    iprot.readStructBegin()
24736 
    while True:
24737 
      (fname, ftype, fid) = iprot.readFieldBegin()
24738 
      if ftype == TType.STOP:
24739 
        break
24740 
      else:
24741 
        iprot.skip(ftype)
24742 
      iprot.readFieldEnd()
24743 
    iprot.readStructEnd()
24744 
 
24745 
  def write(self, oprot):
24746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24748 
      return
24749 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
24750 
    oprot.writeFieldStop()
24751 
    oprot.writeStructEnd()
24752 
 
24753 
  def validate(self):
24754 
    return
24755 
 
24756 
 
24757 
  def __repr__(self):
24758 
    L = ['%s=%r' % (key, value)
24759 
      for key, value in self.__dict__.iteritems()]
24760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24761 
 
24762 
  def __eq__(self, other):
24763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24764 
 
24765 
  def __ne__(self, other):
24766 
    return not (self == other)
24767 
 
24768 
class getCountForSnapdealItems_result:
24769 
  """
24770 
  Attributes:
24771 
   - success
24772 
  """
24773 
 
24774 
  thrift_spec = (
24775 
    (0, TType.I64, 'success', None, None, ), # 0
24776 
  )
24777 
 
24778 
  def __init__(self, success=None,):
24779 
    self.success = success
24780 
 
24781 
  def read(self, iprot):
24782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24784 
      return
24785 
    iprot.readStructBegin()
24786 
    while True:
24787 
      (fname, ftype, fid) = iprot.readFieldBegin()
24788 
      if ftype == TType.STOP:
24789 
        break
24790 
      if fid == 0:
24791 
        if ftype == TType.I64:
24792 
          self.success = iprot.readI64();
24793 
        else:
24794 
          iprot.skip(ftype)
24795 
      else:
24796 
        iprot.skip(ftype)
24797 
      iprot.readFieldEnd()
24798 
    iprot.readStructEnd()
24799 
 
24800 
  def write(self, oprot):
24801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24803 
      return
24804 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
24805 
    if self.success is not None:
24806 
      oprot.writeFieldBegin('success', TType.I64, 0)
24807 
      oprot.writeI64(self.success)
24808 
      oprot.writeFieldEnd()
24809 
    oprot.writeFieldStop()
24810 
    oprot.writeStructEnd()
24811 
 
24812 
  def validate(self):
24813 
    return
24814 
 
24815 
 
24816 
  def __repr__(self):
24817 
    L = ['%s=%r' % (key, value)
24818 
      for key, value in self.__dict__.iteritems()]
24819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24820 
 
24821 
  def __eq__(self, other):
24822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24823 
 
24824 
  def __ne__(self, other):
24825 
    return not (self == other)
24826 
 
24827 
class getSnapdealSearchResultCount_args:
24828 
  """
24829 
  Attributes:
24830 
   - searchTerm
24831 
  """
24832 
 
24833 
  thrift_spec = (
24834 
    None, # 0
24835 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
24836 
  )
24837 
 
24838 
  def __init__(self, searchTerm=None,):
24839 
    self.searchTerm = searchTerm
24840 
 
24841 
  def read(self, iprot):
24842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24844 
      return
24845 
    iprot.readStructBegin()
24846 
    while True:
24847 
      (fname, ftype, fid) = iprot.readFieldBegin()
24848 
      if ftype == TType.STOP:
24849 
        break
24850 
      if fid == 1:
24851 
        if ftype == TType.LIST:
24852 
          self.searchTerm = []
24853 
          (_etype544, _size541) = iprot.readListBegin()
24854 
          for _i545 in xrange(_size541):
24855 
            _elem546 = iprot.readString();
24856 
            self.searchTerm.append(_elem546)
24857 
          iprot.readListEnd()
24858 
        else:
24859 
          iprot.skip(ftype)
24860 
      else:
24861 
        iprot.skip(ftype)
24862 
      iprot.readFieldEnd()
24863 
    iprot.readStructEnd()
24864 
 
24865 
  def write(self, oprot):
24866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24868 
      return
24869 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
24870 
    if self.searchTerm is not None:
24871 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
24872 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
24873 
      for iter547 in self.searchTerm:
24874 
        oprot.writeString(iter547)
24875 
      oprot.writeListEnd()
24876 
      oprot.writeFieldEnd()
24877 
    oprot.writeFieldStop()
24878 
    oprot.writeStructEnd()
24879 
 
24880 
  def validate(self):
24881 
    return
24882 
 
24883 
 
24884 
  def __repr__(self):
24885 
    L = ['%s=%r' % (key, value)
24886 
      for key, value in self.__dict__.iteritems()]
24887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24888 
 
24889 
  def __eq__(self, other):
24890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24891 
 
24892 
  def __ne__(self, other):
24893 
    return not (self == other)
24894 
 
24895 
class getSnapdealSearchResultCount_result:
24896 
  """
24897 
  Attributes:
24898 
   - success
24899 
  """
24900 
 
24901 
  thrift_spec = (
24902 
    (0, TType.I64, 'success', None, None, ), # 0
24903 
  )
24904 
 
24905 
  def __init__(self, success=None,):
24906 
    self.success = success
24907 
 
24908 
  def read(self, iprot):
24909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24911 
      return
24912 
    iprot.readStructBegin()
24913 
    while True:
24914 
      (fname, ftype, fid) = iprot.readFieldBegin()
24915 
      if ftype == TType.STOP:
24916 
        break
24917 
      if fid == 0:
24918 
        if ftype == TType.I64:
24919 
          self.success = iprot.readI64();
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('getSnapdealSearchResultCount_result')
24932 
    if self.success is not None:
24933 
      oprot.writeFieldBegin('success', TType.I64, 0)
24934 
      oprot.writeI64(self.success)
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)
9299 kshitij.so 24953 
 
24954 
class getPrefferedInsurerForItem_args:
24955 
  """
24956 
  Attributes:
24957 
   - itemId
24958 
   - insurerType
24959 
  """
24960 
 
24961 
  thrift_spec = (
24962 
    None, # 0
24963 
    (1, TType.I64, 'itemId', None, None, ), # 1
24964 
    (2, TType.I32, 'insurerType', None, None, ), # 2
24965 
  )
24966 
 
24967 
  def __init__(self, itemId=None, insurerType=None,):
24968 
    self.itemId = itemId
24969 
    self.insurerType = insurerType
24970 
 
24971 
  def read(self, iprot):
24972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24974 
      return
24975 
    iprot.readStructBegin()
24976 
    while True:
24977 
      (fname, ftype, fid) = iprot.readFieldBegin()
24978 
      if ftype == TType.STOP:
24979 
        break
24980 
      if fid == 1:
24981 
        if ftype == TType.I64:
24982 
          self.itemId = iprot.readI64();
24983 
        else:
24984 
          iprot.skip(ftype)
24985 
      elif fid == 2:
24986 
        if ftype == TType.I32:
24987 
          self.insurerType = iprot.readI32();
24988 
        else:
24989 
          iprot.skip(ftype)
24990 
      else:
24991 
        iprot.skip(ftype)
24992 
      iprot.readFieldEnd()
24993 
    iprot.readStructEnd()
24994 
 
24995 
  def write(self, oprot):
24996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24998 
      return
24999 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
25000 
    if self.itemId is not None:
25001 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25002 
      oprot.writeI64(self.itemId)
25003 
      oprot.writeFieldEnd()
25004 
    if self.insurerType is not None:
25005 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
25006 
      oprot.writeI32(self.insurerType)
25007 
      oprot.writeFieldEnd()
25008 
    oprot.writeFieldStop()
25009 
    oprot.writeStructEnd()
25010 
 
25011 
  def validate(self):
25012 
    return
25013 
 
25014 
 
25015 
  def __repr__(self):
25016 
    L = ['%s=%r' % (key, value)
25017 
      for key, value in self.__dict__.iteritems()]
25018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25019 
 
25020 
  def __eq__(self, other):
25021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25022 
 
25023 
  def __ne__(self, other):
25024 
    return not (self == other)
25025 
 
25026 
class getPrefferedInsurerForItem_result:
25027 
  """
25028 
  Attributes:
25029 
   - success
25030 
  """
25031 
 
25032 
  thrift_spec = (
25033 
    (0, TType.I64, 'success', None, None, ), # 0
25034 
  )
25035 
 
25036 
  def __init__(self, success=None,):
25037 
    self.success = success
25038 
 
25039 
  def read(self, iprot):
25040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25042 
      return
25043 
    iprot.readStructBegin()
25044 
    while True:
25045 
      (fname, ftype, fid) = iprot.readFieldBegin()
25046 
      if ftype == TType.STOP:
25047 
        break
25048 
      if fid == 0:
25049 
        if ftype == TType.I64:
25050 
          self.success = iprot.readI64();
25051 
        else:
25052 
          iprot.skip(ftype)
25053 
      else:
25054 
        iprot.skip(ftype)
25055 
      iprot.readFieldEnd()
25056 
    iprot.readStructEnd()
25057 
 
25058 
  def write(self, oprot):
25059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25061 
      return
25062 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
25063 
    if self.success is not None:
25064 
      oprot.writeFieldBegin('success', TType.I64, 0)
25065 
      oprot.writeI64(self.success)
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)
9456 vikram.rag 25084 
 
25085 
class getSnapdealItembySkuAtSnapdeal_args:
25086 
  """
25087 
  Attributes:
25088 
   - skuAtSnapdeal
25089 
  """
25090 
 
25091 
  thrift_spec = None
25092 
  def __init__(self, skuAtSnapdeal=None,):
25093 
    self.skuAtSnapdeal = skuAtSnapdeal
25094 
 
25095 
  def read(self, iprot):
25096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25098 
      return
25099 
    iprot.readStructBegin()
25100 
    while True:
25101 
      (fname, ftype, fid) = iprot.readFieldBegin()
25102 
      if ftype == TType.STOP:
25103 
        break
25104 
      if fid == -1:
25105 
        if ftype == TType.STRING:
25106 
          self.skuAtSnapdeal = iprot.readString();
25107 
        else:
25108 
          iprot.skip(ftype)
25109 
      else:
25110 
        iprot.skip(ftype)
25111 
      iprot.readFieldEnd()
25112 
    iprot.readStructEnd()
25113 
 
25114 
  def write(self, oprot):
25115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25117 
      return
25118 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
25119 
    if self.skuAtSnapdeal is not None:
25120 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
25121 
      oprot.writeString(self.skuAtSnapdeal)
25122 
      oprot.writeFieldEnd()
25123 
    oprot.writeFieldStop()
25124 
    oprot.writeStructEnd()
25125 
 
25126 
  def validate(self):
25127 
    return
25128 
 
25129 
 
25130 
  def __repr__(self):
25131 
    L = ['%s=%r' % (key, value)
25132 
      for key, value in self.__dict__.iteritems()]
25133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25134 
 
25135 
  def __eq__(self, other):
25136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25137 
 
25138 
  def __ne__(self, other):
25139 
    return not (self == other)
25140 
 
25141 
class getSnapdealItembySkuAtSnapdeal_result:
25142 
  """
25143 
  Attributes:
25144 
   - success
25145 
  """
25146 
 
25147 
  thrift_spec = (
25148 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
25149 
  )
25150 
 
25151 
  def __init__(self, success=None,):
25152 
    self.success = success
25153 
 
25154 
  def read(self, iprot):
25155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25157 
      return
25158 
    iprot.readStructBegin()
25159 
    while True:
25160 
      (fname, ftype, fid) = iprot.readFieldBegin()
25161 
      if ftype == TType.STOP:
25162 
        break
25163 
      if fid == 0:
25164 
        if ftype == TType.STRUCT:
25165 
          self.success = SnapdealItem()
25166 
          self.success.read(iprot)
25167 
        else:
25168 
          iprot.skip(ftype)
25169 
      else:
25170 
        iprot.skip(ftype)
25171 
      iprot.readFieldEnd()
25172 
    iprot.readStructEnd()
25173 
 
25174 
  def write(self, oprot):
25175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25177 
      return
25178 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
25179 
    if self.success is not None:
25180 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25181 
      self.success.write(oprot)
25182 
      oprot.writeFieldEnd()
25183 
    oprot.writeFieldStop()
25184 
    oprot.writeStructEnd()
25185 
 
25186 
  def validate(self):
25187 
    return
25188 
 
25189 
 
25190 
  def __repr__(self):
25191 
    L = ['%s=%r' % (key, value)
25192 
      for key, value in self.__dict__.iteritems()]
25193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25194 
 
25195 
  def __eq__(self, other):
25196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25197 
 
25198 
  def __ne__(self, other):
25199 
    return not (self == other)
9621 manish.sha 25200 
 
25201 
class getProductFeedSubmit_args:
25202 
  """
25203 
  Attributes:
25204 
   - catalogItemId
25205 
  """
25206 
 
25207 
  thrift_spec = (
25208 
    None, # 0
25209 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
25210 
  )
25211 
 
25212 
  def __init__(self, catalogItemId=None,):
25213 
    self.catalogItemId = catalogItemId
25214 
 
25215 
  def read(self, iprot):
25216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25218 
      return
25219 
    iprot.readStructBegin()
25220 
    while True:
25221 
      (fname, ftype, fid) = iprot.readFieldBegin()
25222 
      if ftype == TType.STOP:
25223 
        break
25224 
      if fid == 1:
25225 
        if ftype == TType.I64:
25226 
          self.catalogItemId = iprot.readI64();
25227 
        else:
25228 
          iprot.skip(ftype)
25229 
      else:
25230 
        iprot.skip(ftype)
25231 
      iprot.readFieldEnd()
25232 
    iprot.readStructEnd()
25233 
 
25234 
  def write(self, oprot):
25235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25237 
      return
25238 
    oprot.writeStructBegin('getProductFeedSubmit_args')
25239 
    if self.catalogItemId is not None:
25240 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
25241 
      oprot.writeI64(self.catalogItemId)
25242 
      oprot.writeFieldEnd()
25243 
    oprot.writeFieldStop()
25244 
    oprot.writeStructEnd()
25245 
 
25246 
  def validate(self):
25247 
    return
25248 
 
25249 
 
25250 
  def __repr__(self):
25251 
    L = ['%s=%r' % (key, value)
25252 
      for key, value in self.__dict__.iteritems()]
25253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25254 
 
25255 
  def __eq__(self, other):
25256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25257 
 
25258 
  def __ne__(self, other):
25259 
    return not (self == other)
25260 
 
25261 
class getProductFeedSubmit_result:
25262 
  """
25263 
  Attributes:
25264 
   - success
25265 
   - cex
25266 
  """
25267 
 
25268 
  thrift_spec = (
25269 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
25270 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25271 
  )
25272 
 
25273 
  def __init__(self, success=None, cex=None,):
25274 
    self.success = success
25275 
    self.cex = cex
25276 
 
25277 
  def read(self, iprot):
25278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25280 
      return
25281 
    iprot.readStructBegin()
25282 
    while True:
25283 
      (fname, ftype, fid) = iprot.readFieldBegin()
25284 
      if ftype == TType.STOP:
25285 
        break
25286 
      if fid == 0:
25287 
        if ftype == TType.STRUCT:
25288 
          self.success = ProductFeedSubmit()
25289 
          self.success.read(iprot)
25290 
        else:
25291 
          iprot.skip(ftype)
25292 
      elif fid == 1:
25293 
        if ftype == TType.STRUCT:
25294 
          self.cex = CatalogServiceException()
25295 
          self.cex.read(iprot)
25296 
        else:
25297 
          iprot.skip(ftype)
25298 
      else:
25299 
        iprot.skip(ftype)
25300 
      iprot.readFieldEnd()
25301 
    iprot.readStructEnd()
25302 
 
25303 
  def write(self, oprot):
25304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25306 
      return
25307 
    oprot.writeStructBegin('getProductFeedSubmit_result')
25308 
    if self.success is not None:
25309 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25310 
      self.success.write(oprot)
25311 
      oprot.writeFieldEnd()
25312 
    if self.cex is not None:
25313 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25314 
      self.cex.write(oprot)
25315 
      oprot.writeFieldEnd()
25316 
    oprot.writeFieldStop()
25317 
    oprot.writeStructEnd()
25318 
 
25319 
  def validate(self):
25320 
    return
25321 
 
25322 
 
25323 
  def __repr__(self):
25324 
    L = ['%s=%r' % (key, value)
25325 
      for key, value in self.__dict__.iteritems()]
25326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25327 
 
25328 
  def __eq__(self, other):
25329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25330 
 
25331 
  def __ne__(self, other):
25332 
    return not (self == other)
25333 
 
25334 
class addProductFeedSubmit_args:
25335 
  """
25336 
  Attributes:
25337 
   - productFeedSubmit
25338 
  """
25339 
 
25340 
  thrift_spec = (
25341 
    None, # 0
25342 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
25343 
  )
25344 
 
25345 
  def __init__(self, productFeedSubmit=None,):
25346 
    self.productFeedSubmit = productFeedSubmit
25347 
 
25348 
  def read(self, iprot):
25349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25351 
      return
25352 
    iprot.readStructBegin()
25353 
    while True:
25354 
      (fname, ftype, fid) = iprot.readFieldBegin()
25355 
      if ftype == TType.STOP:
25356 
        break
25357 
      if fid == 1:
25358 
        if ftype == TType.STRUCT:
25359 
          self.productFeedSubmit = ProductFeedSubmit()
25360 
          self.productFeedSubmit.read(iprot)
25361 
        else:
25362 
          iprot.skip(ftype)
25363 
      else:
25364 
        iprot.skip(ftype)
25365 
      iprot.readFieldEnd()
25366 
    iprot.readStructEnd()
25367 
 
25368 
  def write(self, oprot):
25369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25371 
      return
25372 
    oprot.writeStructBegin('addProductFeedSubmit_args')
25373 
    if self.productFeedSubmit is not None:
25374 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
25375 
      self.productFeedSubmit.write(oprot)
25376 
      oprot.writeFieldEnd()
25377 
    oprot.writeFieldStop()
25378 
    oprot.writeStructEnd()
25379 
 
25380 
  def validate(self):
25381 
    return
25382 
 
25383 
 
25384 
  def __repr__(self):
25385 
    L = ['%s=%r' % (key, value)
25386 
      for key, value in self.__dict__.iteritems()]
25387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25388 
 
25389 
  def __eq__(self, other):
25390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25391 
 
25392 
  def __ne__(self, other):
25393 
    return not (self == other)
25394 
 
25395 
class addProductFeedSubmit_result:
25396 
  """
25397 
  Attributes:
25398 
   - success
25399 
   - cex
25400 
  """
25401 
 
25402 
  thrift_spec = (
25403 
    (0, TType.BOOL, 'success', None, None, ), # 0
25404 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25405 
  )
25406 
 
25407 
  def __init__(self, success=None, cex=None,):
25408 
    self.success = success
25409 
    self.cex = cex
25410 
 
25411 
  def read(self, iprot):
25412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25414 
      return
25415 
    iprot.readStructBegin()
25416 
    while True:
25417 
      (fname, ftype, fid) = iprot.readFieldBegin()
25418 
      if ftype == TType.STOP:
25419 
        break
25420 
      if fid == 0:
25421 
        if ftype == TType.BOOL:
25422 
          self.success = iprot.readBool();
25423 
        else:
25424 
          iprot.skip(ftype)
25425 
      elif fid == 1:
25426 
        if ftype == TType.STRUCT:
25427 
          self.cex = CatalogServiceException()
25428 
          self.cex.read(iprot)
25429 
        else:
25430 
          iprot.skip(ftype)
25431 
      else:
25432 
        iprot.skip(ftype)
25433 
      iprot.readFieldEnd()
25434 
    iprot.readStructEnd()
25435 
 
25436 
  def write(self, oprot):
25437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25439 
      return
25440 
    oprot.writeStructBegin('addProductFeedSubmit_result')
25441 
    if self.success is not None:
25442 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25443 
      oprot.writeBool(self.success)
25444 
      oprot.writeFieldEnd()
25445 
    if self.cex is not None:
25446 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25447 
      self.cex.write(oprot)
25448 
      oprot.writeFieldEnd()
25449 
    oprot.writeFieldStop()
25450 
    oprot.writeStructEnd()
25451 
 
25452 
  def validate(self):
25453 
    return
25454 
 
25455 
 
25456 
  def __repr__(self):
25457 
    L = ['%s=%r' % (key, value)
25458 
      for key, value in self.__dict__.iteritems()]
25459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25460 
 
25461 
  def __eq__(self, other):
25462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25463 
 
25464 
  def __ne__(self, other):
25465 
    return not (self == other)
25466 
 
25467 
class updateProductFeedSubmit_args:
25468 
  """
25469 
  Attributes:
25470 
   - productFeedSubmit
25471 
  """
25472 
 
25473 
  thrift_spec = (
25474 
    None, # 0
25475 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
25476 
  )
25477 
 
25478 
  def __init__(self, productFeedSubmit=None,):
25479 
    self.productFeedSubmit = productFeedSubmit
25480 
 
25481 
  def read(self, iprot):
25482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25484 
      return
25485 
    iprot.readStructBegin()
25486 
    while True:
25487 
      (fname, ftype, fid) = iprot.readFieldBegin()
25488 
      if ftype == TType.STOP:
25489 
        break
25490 
      if fid == 1:
25491 
        if ftype == TType.STRUCT:
25492 
          self.productFeedSubmit = ProductFeedSubmit()
25493 
          self.productFeedSubmit.read(iprot)
25494 
        else:
25495 
          iprot.skip(ftype)
25496 
      else:
25497 
        iprot.skip(ftype)
25498 
      iprot.readFieldEnd()
25499 
    iprot.readStructEnd()
25500 
 
25501 
  def write(self, oprot):
25502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25504 
      return
25505 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
25506 
    if self.productFeedSubmit is not None:
25507 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
25508 
      self.productFeedSubmit.write(oprot)
25509 
      oprot.writeFieldEnd()
25510 
    oprot.writeFieldStop()
25511 
    oprot.writeStructEnd()
25512 
 
25513 
  def validate(self):
25514 
    return
25515 
 
25516 
 
25517 
  def __repr__(self):
25518 
    L = ['%s=%r' % (key, value)
25519 
      for key, value in self.__dict__.iteritems()]
25520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25521 
 
25522 
  def __eq__(self, other):
25523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25524 
 
25525 
  def __ne__(self, other):
25526 
    return not (self == other)
25527 
 
25528 
class updateProductFeedSubmit_result:
25529 
  """
25530 
  Attributes:
25531 
   - success
25532 
   - cex
25533 
  """
25534 
 
25535 
  thrift_spec = (
25536 
    (0, TType.BOOL, 'success', None, None, ), # 0
25537 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25538 
  )
25539 
 
25540 
  def __init__(self, success=None, cex=None,):
25541 
    self.success = success
25542 
    self.cex = cex
25543 
 
25544 
  def read(self, iprot):
25545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25547 
      return
25548 
    iprot.readStructBegin()
25549 
    while True:
25550 
      (fname, ftype, fid) = iprot.readFieldBegin()
25551 
      if ftype == TType.STOP:
25552 
        break
25553 
      if fid == 0:
25554 
        if ftype == TType.BOOL:
25555 
          self.success = iprot.readBool();
25556 
        else:
25557 
          iprot.skip(ftype)
25558 
      elif fid == 1:
25559 
        if ftype == TType.STRUCT:
25560 
          self.cex = CatalogServiceException()
25561 
          self.cex.read(iprot)
25562 
        else:
25563 
          iprot.skip(ftype)
25564 
      else:
25565 
        iprot.skip(ftype)
25566 
      iprot.readFieldEnd()
25567 
    iprot.readStructEnd()
25568 
 
25569 
  def write(self, oprot):
25570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25572 
      return
25573 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
25574 
    if self.success is not None:
25575 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25576 
      oprot.writeBool(self.success)
25577 
      oprot.writeFieldEnd()
25578 
    if self.cex is not None:
25579 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25580 
      self.cex.write(oprot)
25581 
      oprot.writeFieldEnd()
25582 
    oprot.writeFieldStop()
25583 
    oprot.writeStructEnd()
25584 
 
25585 
  def validate(self):
25586 
    return
25587 
 
25588 
 
25589 
  def __repr__(self):
25590 
    L = ['%s=%r' % (key, value)
25591 
      for key, value in self.__dict__.iteritems()]
25592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25593 
 
25594 
  def __eq__(self, other):
25595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25596 
 
25597 
  def __ne__(self, other):
25598 
    return not (self == other)
25599 
 
25600 
class deleteProductFeedSubmit_args:
25601 
  """
25602 
  Attributes:
25603 
   - catalogItemId
25604 
  """
25605 
 
25606 
  thrift_spec = (
25607 
    None, # 0
25608 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
25609 
  )
25610 
 
25611 
  def __init__(self, catalogItemId=None,):
25612 
    self.catalogItemId = catalogItemId
25613 
 
25614 
  def read(self, iprot):
25615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25617 
      return
25618 
    iprot.readStructBegin()
25619 
    while True:
25620 
      (fname, ftype, fid) = iprot.readFieldBegin()
25621 
      if ftype == TType.STOP:
25622 
        break
25623 
      if fid == 1:
25624 
        if ftype == TType.I64:
25625 
          self.catalogItemId = iprot.readI64();
25626 
        else:
25627 
          iprot.skip(ftype)
25628 
      else:
25629 
        iprot.skip(ftype)
25630 
      iprot.readFieldEnd()
25631 
    iprot.readStructEnd()
25632 
 
25633 
  def write(self, oprot):
25634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25636 
      return
25637 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
25638 
    if self.catalogItemId is not None:
25639 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
25640 
      oprot.writeI64(self.catalogItemId)
25641 
      oprot.writeFieldEnd()
25642 
    oprot.writeFieldStop()
25643 
    oprot.writeStructEnd()
25644 
 
25645 
  def validate(self):
25646 
    return
25647 
 
25648 
 
25649 
  def __repr__(self):
25650 
    L = ['%s=%r' % (key, value)
25651 
      for key, value in self.__dict__.iteritems()]
25652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25653 
 
25654 
  def __eq__(self, other):
25655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25656 
 
25657 
  def __ne__(self, other):
25658 
    return not (self == other)
25659 
 
25660 
class deleteProductFeedSubmit_result:
25661 
  """
25662 
  Attributes:
25663 
   - success
25664 
   - cex
25665 
  """
25666 
 
25667 
  thrift_spec = (
25668 
    (0, TType.BOOL, 'success', None, None, ), # 0
25669 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25670 
  )
25671 
 
25672 
  def __init__(self, success=None, cex=None,):
25673 
    self.success = success
25674 
    self.cex = cex
25675 
 
25676 
  def read(self, iprot):
25677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25679 
      return
25680 
    iprot.readStructBegin()
25681 
    while True:
25682 
      (fname, ftype, fid) = iprot.readFieldBegin()
25683 
      if ftype == TType.STOP:
25684 
        break
25685 
      if fid == 0:
25686 
        if ftype == TType.BOOL:
25687 
          self.success = iprot.readBool();
25688 
        else:
25689 
          iprot.skip(ftype)
25690 
      elif fid == 1:
25691 
        if ftype == TType.STRUCT:
25692 
          self.cex = CatalogServiceException()
25693 
          self.cex.read(iprot)
25694 
        else:
25695 
          iprot.skip(ftype)
25696 
      else:
25697 
        iprot.skip(ftype)
25698 
      iprot.readFieldEnd()
25699 
    iprot.readStructEnd()
25700 
 
25701 
  def write(self, oprot):
25702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25704 
      return
25705 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
25706 
    if self.success is not None:
25707 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25708 
      oprot.writeBool(self.success)
25709 
      oprot.writeFieldEnd()
25710 
    if self.cex is not None:
25711 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25712 
      self.cex.write(oprot)
25713 
      oprot.writeFieldEnd()
25714 
    oprot.writeFieldStop()
25715 
    oprot.writeStructEnd()
25716 
 
25717 
  def validate(self):
25718 
    return
25719 
 
25720 
 
25721 
  def __repr__(self):
25722 
    L = ['%s=%r' % (key, value)
25723 
      for key, value in self.__dict__.iteritems()]
25724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25725 
 
25726 
  def __eq__(self, other):
25727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25728 
 
25729 
  def __ne__(self, other):
25730 
    return not (self == other)
25731 
 
25732 
class getAllProductFeedSubmit_args:
25733 
 
25734 
  thrift_spec = (
25735 
  )
25736 
 
25737 
  def read(self, iprot):
25738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25740 
      return
25741 
    iprot.readStructBegin()
25742 
    while True:
25743 
      (fname, ftype, fid) = iprot.readFieldBegin()
25744 
      if ftype == TType.STOP:
25745 
        break
25746 
      else:
25747 
        iprot.skip(ftype)
25748 
      iprot.readFieldEnd()
25749 
    iprot.readStructEnd()
25750 
 
25751 
  def write(self, oprot):
25752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25754 
      return
25755 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
25756 
    oprot.writeFieldStop()
25757 
    oprot.writeStructEnd()
25758 
 
25759 
  def validate(self):
25760 
    return
25761 
 
25762 
 
25763 
  def __repr__(self):
25764 
    L = ['%s=%r' % (key, value)
25765 
      for key, value in self.__dict__.iteritems()]
25766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25767 
 
25768 
  def __eq__(self, other):
25769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25770 
 
25771 
  def __ne__(self, other):
25772 
    return not (self == other)
25773 
 
25774 
class getAllProductFeedSubmit_result:
25775 
  """
25776 
  Attributes:
25777 
   - success
25778 
   - cex
25779 
  """
25780 
 
25781 
  thrift_spec = (
25782 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
25783 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25784 
  )
25785 
 
25786 
  def __init__(self, success=None, cex=None,):
25787 
    self.success = success
25788 
    self.cex = cex
25789 
 
25790 
  def read(self, iprot):
25791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25793 
      return
25794 
    iprot.readStructBegin()
25795 
    while True:
25796 
      (fname, ftype, fid) = iprot.readFieldBegin()
25797 
      if ftype == TType.STOP:
25798 
        break
25799 
      if fid == 0:
25800 
        if ftype == TType.LIST:
25801 
          self.success = []
25802 
          (_etype551, _size548) = iprot.readListBegin()
25803 
          for _i552 in xrange(_size548):
25804 
            _elem553 = ProductFeedSubmit()
25805 
            _elem553.read(iprot)
25806 
            self.success.append(_elem553)
25807 
          iprot.readListEnd()
25808 
        else:
25809 
          iprot.skip(ftype)
25810 
      elif fid == 1:
25811 
        if ftype == TType.STRUCT:
25812 
          self.cex = CatalogServiceException()
25813 
          self.cex.read(iprot)
25814 
        else:
25815 
          iprot.skip(ftype)
25816 
      else:
25817 
        iprot.skip(ftype)
25818 
      iprot.readFieldEnd()
25819 
    iprot.readStructEnd()
25820 
 
25821 
  def write(self, oprot):
25822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25824 
      return
25825 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
25826 
    if self.success is not None:
25827 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25828 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25829 
      for iter554 in self.success:
25830 
        iter554.write(oprot)
25831 
      oprot.writeListEnd()
25832 
      oprot.writeFieldEnd()
25833 
    if self.cex is not None:
25834 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25835 
      self.cex.write(oprot)
25836 
      oprot.writeFieldEnd()
25837 
    oprot.writeFieldStop()
25838 
    oprot.writeStructEnd()
25839 
 
25840 
  def validate(self):
25841 
    return
25842 
 
25843 
 
25844 
  def __repr__(self):
25845 
    L = ['%s=%r' % (key, value)
25846 
      for key, value in self.__dict__.iteritems()]
25847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25848 
 
25849 
  def __eq__(self, other):
25850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25851 
 
25852 
  def __ne__(self, other):
25853 
    return not (self == other)
9724 kshitij.so 25854 
 
25855 
class getMarketplacedetailsForItem_args:
25856 
  """
25857 
  Attributes:
25858 
   - itemId
25859 
   - sourceId
25860 
  """
25861 
 
25862 
  thrift_spec = (
25863 
    None, # 0
25864 
    (1, TType.I64, 'itemId', None, None, ), # 1
25865 
    (2, TType.I64, 'sourceId', None, None, ), # 2
25866 
  )
25867 
 
25868 
  def __init__(self, itemId=None, sourceId=None,):
25869 
    self.itemId = itemId
25870 
    self.sourceId = sourceId
25871 
 
25872 
  def read(self, iprot):
25873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25875 
      return
25876 
    iprot.readStructBegin()
25877 
    while True:
25878 
      (fname, ftype, fid) = iprot.readFieldBegin()
25879 
      if ftype == TType.STOP:
25880 
        break
25881 
      if fid == 1:
25882 
        if ftype == TType.I64:
25883 
          self.itemId = iprot.readI64();
25884 
        else:
25885 
          iprot.skip(ftype)
25886 
      elif fid == 2:
25887 
        if ftype == TType.I64:
25888 
          self.sourceId = iprot.readI64();
25889 
        else:
25890 
          iprot.skip(ftype)
25891 
      else:
25892 
        iprot.skip(ftype)
25893 
      iprot.readFieldEnd()
25894 
    iprot.readStructEnd()
25895 
 
25896 
  def write(self, oprot):
25897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25899 
      return
25900 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
25901 
    if self.itemId is not None:
25902 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25903 
      oprot.writeI64(self.itemId)
25904 
      oprot.writeFieldEnd()
25905 
    if self.sourceId is not None:
25906 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
25907 
      oprot.writeI64(self.sourceId)
25908 
      oprot.writeFieldEnd()
25909 
    oprot.writeFieldStop()
25910 
    oprot.writeStructEnd()
25911 
 
25912 
  def validate(self):
25913 
    return
25914 
 
25915 
 
25916 
  def __repr__(self):
25917 
    L = ['%s=%r' % (key, value)
25918 
      for key, value in self.__dict__.iteritems()]
25919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25920 
 
25921 
  def __eq__(self, other):
25922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25923 
 
25924 
  def __ne__(self, other):
25925 
    return not (self == other)
25926 
 
25927 
class getMarketplacedetailsForItem_result:
25928 
  """
25929 
  Attributes:
25930 
   - success
25931 
  """
25932 
 
25933 
  thrift_spec = (
25934 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
25935 
  )
25936 
 
25937 
  def __init__(self, success=None,):
25938 
    self.success = success
25939 
 
25940 
  def read(self, iprot):
25941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25943 
      return
25944 
    iprot.readStructBegin()
25945 
    while True:
25946 
      (fname, ftype, fid) = iprot.readFieldBegin()
25947 
      if ftype == TType.STOP:
25948 
        break
25949 
      if fid == 0:
25950 
        if ftype == TType.STRUCT:
25951 
          self.success = MarketplaceItems()
25952 
          self.success.read(iprot)
25953 
        else:
25954 
          iprot.skip(ftype)
25955 
      else:
25956 
        iprot.skip(ftype)
25957 
      iprot.readFieldEnd()
25958 
    iprot.readStructEnd()
25959 
 
25960 
  def write(self, oprot):
25961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25963 
      return
25964 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
25965 
    if self.success is not None:
25966 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25967 
      self.success.write(oprot)
25968 
      oprot.writeFieldEnd()
25969 
    oprot.writeFieldStop()
25970 
    oprot.writeStructEnd()
25971 
 
25972 
  def validate(self):
25973 
    return
25974 
 
25975 
 
25976 
  def __repr__(self):
25977 
    L = ['%s=%r' % (key, value)
25978 
      for key, value in self.__dict__.iteritems()]
25979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25980 
 
25981 
  def __eq__(self, other):
25982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25983 
 
25984 
  def __ne__(self, other):
25985 
    return not (self == other)
25986 
 
25987 
class updateMarketplaceAttributesForItem_args:
25988 
  """
25989 
  Attributes:
25990 
   - marketPlaceItem
25991 
  """
25992 
 
25993 
  thrift_spec = (
25994 
    None, # 0
25995 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
25996 
  )
25997 
 
25998 
  def __init__(self, marketPlaceItem=None,):
25999 
    self.marketPlaceItem = marketPlaceItem
26000 
 
26001 
  def read(self, iprot):
26002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26004 
      return
26005 
    iprot.readStructBegin()
26006 
    while True:
26007 
      (fname, ftype, fid) = iprot.readFieldBegin()
26008 
      if ftype == TType.STOP:
26009 
        break
26010 
      if fid == 1:
26011 
        if ftype == TType.STRUCT:
26012 
          self.marketPlaceItem = MarketplaceItems()
26013 
          self.marketPlaceItem.read(iprot)
26014 
        else:
26015 
          iprot.skip(ftype)
26016 
      else:
26017 
        iprot.skip(ftype)
26018 
      iprot.readFieldEnd()
26019 
    iprot.readStructEnd()
26020 
 
26021 
  def write(self, oprot):
26022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26024 
      return
26025 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
26026 
    if self.marketPlaceItem is not None:
26027 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
26028 
      self.marketPlaceItem.write(oprot)
26029 
      oprot.writeFieldEnd()
26030 
    oprot.writeFieldStop()
26031 
    oprot.writeStructEnd()
26032 
 
26033 
  def validate(self):
26034 
    return
26035 
 
26036 
 
26037 
  def __repr__(self):
26038 
    L = ['%s=%r' % (key, value)
26039 
      for key, value in self.__dict__.iteritems()]
26040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26041 
 
26042 
  def __eq__(self, other):
26043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26044 
 
26045 
  def __ne__(self, other):
26046 
    return not (self == other)
26047 
 
26048 
class updateMarketplaceAttributesForItem_result:
26049 
  """
26050 
  Attributes:
26051 
   - success
26052 
  """
26053 
 
26054 
  thrift_spec = (
26055 
    (0, TType.BOOL, 'success', None, None, ), # 0
26056 
  )
26057 
 
26058 
  def __init__(self, success=None,):
26059 
    self.success = success
26060 
 
26061 
  def read(self, iprot):
26062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26064 
      return
26065 
    iprot.readStructBegin()
26066 
    while True:
26067 
      (fname, ftype, fid) = iprot.readFieldBegin()
26068 
      if ftype == TType.STOP:
26069 
        break
26070 
      if fid == 0:
26071 
        if ftype == TType.BOOL:
26072 
          self.success = iprot.readBool();
26073 
        else:
26074 
          iprot.skip(ftype)
26075 
      else:
26076 
        iprot.skip(ftype)
26077 
      iprot.readFieldEnd()
26078 
    iprot.readStructEnd()
26079 
 
26080 
  def write(self, oprot):
26081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26083 
      return
26084 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
26085 
    if self.success is not None:
26086 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26087 
      oprot.writeBool(self.success)
26088 
      oprot.writeFieldEnd()
26089 
    oprot.writeFieldStop()
26090 
    oprot.writeStructEnd()
26091 
 
26092 
  def validate(self):
26093 
    return
26094 
 
26095 
 
26096 
  def __repr__(self):
26097 
    L = ['%s=%r' % (key, value)
26098 
      for key, value in self.__dict__.iteritems()]
26099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26100 
 
26101 
  def __eq__(self, other):
26102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26103 
 
26104 
  def __ne__(self, other):
26105 
    return not (self == other)
9776 vikram.rag 26106 
 
9779 kshitij.so 26107 
class getCostingForMarketplace_args:
26108 
  """
26109 
  Attributes:
26110 
   - source
26111 
   - item_id
26112 
  """
26113 
 
26114 
  thrift_spec = (
26115 
    None, # 0
26116 
    (1, TType.I64, 'source', None, None, ), # 1
26117 
    (2, TType.I64, 'item_id', None, None, ), # 2
26118 
  )
26119 
 
26120 
  def __init__(self, source=None, item_id=None,):
26121 
    self.source = source
26122 
    self.item_id = item_id
26123 
 
26124 
  def read(self, iprot):
26125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26127 
      return
26128 
    iprot.readStructBegin()
26129 
    while True:
26130 
      (fname, ftype, fid) = iprot.readFieldBegin()
26131 
      if ftype == TType.STOP:
26132 
        break
26133 
      if fid == 1:
26134 
        if ftype == TType.I64:
26135 
          self.source = iprot.readI64();
26136 
        else:
26137 
          iprot.skip(ftype)
26138 
      elif fid == 2:
26139 
        if ftype == TType.I64:
26140 
          self.item_id = iprot.readI64();
26141 
        else:
26142 
          iprot.skip(ftype)
26143 
      else:
26144 
        iprot.skip(ftype)
26145 
      iprot.readFieldEnd()
26146 
    iprot.readStructEnd()
26147 
 
26148 
  def write(self, oprot):
26149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26151 
      return
26152 
    oprot.writeStructBegin('getCostingForMarketplace_args')
26153 
    if self.source is not None:
26154 
      oprot.writeFieldBegin('source', TType.I64, 1)
26155 
      oprot.writeI64(self.source)
26156 
      oprot.writeFieldEnd()
26157 
    if self.item_id is not None:
26158 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
26159 
      oprot.writeI64(self.item_id)
26160 
      oprot.writeFieldEnd()
26161 
    oprot.writeFieldStop()
26162 
    oprot.writeStructEnd()
26163 
 
26164 
  def validate(self):
26165 
    return
26166 
 
26167 
 
26168 
  def __repr__(self):
26169 
    L = ['%s=%r' % (key, value)
26170 
      for key, value in self.__dict__.iteritems()]
26171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26172 
 
26173 
  def __eq__(self, other):
26174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26175 
 
26176 
  def __ne__(self, other):
26177 
    return not (self == other)
26178 
 
26179 
class getCostingForMarketplace_result:
26180 
  """
26181 
  Attributes:
26182 
   - success
26183 
  """
26184 
 
26185 
  thrift_spec = (
26186 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
26187 
  )
26188 
 
26189 
  def __init__(self, success=None,):
26190 
    self.success = success
26191 
 
26192 
  def read(self, iprot):
26193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26195 
      return
26196 
    iprot.readStructBegin()
26197 
    while True:
26198 
      (fname, ftype, fid) = iprot.readFieldBegin()
26199 
      if ftype == TType.STOP:
26200 
        break
26201 
      if fid == 0:
26202 
        if ftype == TType.STRUCT:
26203 
          self.success = MarketplacePercentage()
26204 
          self.success.read(iprot)
26205 
        else:
26206 
          iprot.skip(ftype)
26207 
      else:
26208 
        iprot.skip(ftype)
26209 
      iprot.readFieldEnd()
26210 
    iprot.readStructEnd()
26211 
 
26212 
  def write(self, oprot):
26213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26215 
      return
26216 
    oprot.writeStructBegin('getCostingForMarketplace_result')
26217 
    if self.success is not None:
26218 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26219 
      self.success.write(oprot)
26220 
      oprot.writeFieldEnd()
26221 
    oprot.writeFieldStop()
26222 
    oprot.writeStructEnd()
26223 
 
26224 
  def validate(self):
26225 
    return
26226 
 
26227 
 
26228 
  def __repr__(self):
26229 
    L = ['%s=%r' % (key, value)
26230 
      for key, value in self.__dict__.iteritems()]
26231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26232 
 
26233 
  def __eq__(self, other):
26234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26235 
 
26236 
  def __ne__(self, other):
26237 
    return not (self == other)
26238 
 
9776 vikram.rag 26239 
class getMarketPlaceItemsForPriceUpdate_args:
26240 
  """
26241 
  Attributes:
26242 
   - source
26243 
  """
26244 
 
26245 
  thrift_spec = (
26246 
    None, # 0
26247 
    (1, TType.I64, 'source', None, None, ), # 1
26248 
  )
26249 
 
26250 
  def __init__(self, source=None,):
26251 
    self.source = source
26252 
 
26253 
  def read(self, iprot):
26254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26256 
      return
26257 
    iprot.readStructBegin()
26258 
    while True:
26259 
      (fname, ftype, fid) = iprot.readFieldBegin()
26260 
      if ftype == TType.STOP:
26261 
        break
26262 
      if fid == 1:
26263 
        if ftype == TType.I64:
26264 
          self.source = iprot.readI64();
26265 
        else:
26266 
          iprot.skip(ftype)
26267 
      else:
26268 
        iprot.skip(ftype)
26269 
      iprot.readFieldEnd()
26270 
    iprot.readStructEnd()
26271 
 
26272 
  def write(self, oprot):
26273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26275 
      return
26276 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
26277 
    if self.source is not None:
26278 
      oprot.writeFieldBegin('source', TType.I64, 1)
26279 
      oprot.writeI64(self.source)
26280 
      oprot.writeFieldEnd()
26281 
    oprot.writeFieldStop()
26282 
    oprot.writeStructEnd()
26283 
 
26284 
  def validate(self):
26285 
    return
26286 
 
26287 
 
26288 
  def __repr__(self):
26289 
    L = ['%s=%r' % (key, value)
26290 
      for key, value in self.__dict__.iteritems()]
26291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26292 
 
26293 
  def __eq__(self, other):
26294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26295 
 
26296 
  def __ne__(self, other):
26297 
    return not (self == other)
26298 
 
26299 
class getMarketPlaceItemsForPriceUpdate_result:
26300 
  """
26301 
  Attributes:
26302 
   - success
26303 
  """
26304 
 
26305 
  thrift_spec = (
26306 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
26307 
  )
26308 
 
26309 
  def __init__(self, success=None,):
26310 
    self.success = success
26311 
 
26312 
  def read(self, iprot):
26313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26315 
      return
26316 
    iprot.readStructBegin()
26317 
    while True:
26318 
      (fname, ftype, fid) = iprot.readFieldBegin()
26319 
      if ftype == TType.STOP:
26320 
        break
26321 
      if fid == 0:
26322 
        if ftype == TType.LIST:
26323 
          self.success = []
26324 
          (_etype558, _size555) = iprot.readListBegin()
26325 
          for _i559 in xrange(_size555):
26326 
            _elem560 = MarketPlaceItemPrice()
26327 
            _elem560.read(iprot)
26328 
            self.success.append(_elem560)
26329 
          iprot.readListEnd()
26330 
        else:
26331 
          iprot.skip(ftype)
26332 
      else:
26333 
        iprot.skip(ftype)
26334 
      iprot.readFieldEnd()
26335 
    iprot.readStructEnd()
26336 
 
26337 
  def write(self, oprot):
26338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26340 
      return
26341 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
26342 
    if self.success is not None:
26343 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26344 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26345 
      for iter561 in self.success:
26346 
        iter561.write(oprot)
26347 
      oprot.writeListEnd()
26348 
      oprot.writeFieldEnd()
26349 
    oprot.writeFieldStop()
26350 
    oprot.writeStructEnd()
26351 
 
26352 
  def validate(self):
26353 
    return
26354 
 
26355 
 
26356 
  def __repr__(self):
26357 
    L = ['%s=%r' % (key, value)
26358 
      for key, value in self.__dict__.iteritems()]
26359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26360 
 
26361 
  def __eq__(self, other):
26362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26363 
 
26364 
  def __ne__(self, other):
26365 
    return not (self == other)
26366 
 
26367 
class updateMarketPlacePriceUpdateStatus_args:
26368 
  """
26369 
  Attributes:
26370 
   - skulist
26371 
   - timestamp
9816 kshitij.so 26372 
   - source
9776 vikram.rag 26373 
  """
26374 
 
26375 
  thrift_spec = (
26376 
    None, # 0
26377 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
26378 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 26379 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 26380 
  )
26381 
 
9816 kshitij.so 26382 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 26383 
    self.skulist = skulist
26384 
    self.timestamp = timestamp
9816 kshitij.so 26385 
    self.source = source
9776 vikram.rag 26386 
 
26387 
  def read(self, iprot):
26388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26390 
      return
26391 
    iprot.readStructBegin()
26392 
    while True:
26393 
      (fname, ftype, fid) = iprot.readFieldBegin()
26394 
      if ftype == TType.STOP:
26395 
        break
26396 
      if fid == 1:
26397 
        if ftype == TType.LIST:
26398 
          self.skulist = []
26399 
          (_etype565, _size562) = iprot.readListBegin()
26400 
          for _i566 in xrange(_size562):
26401 
            _elem567 = iprot.readI64();
26402 
            self.skulist.append(_elem567)
26403 
          iprot.readListEnd()
26404 
        else:
26405 
          iprot.skip(ftype)
26406 
      elif fid == 2:
26407 
        if ftype == TType.I64:
26408 
          self.timestamp = iprot.readI64();
26409 
        else:
26410 
          iprot.skip(ftype)
9816 kshitij.so 26411 
      elif fid == 3:
26412 
        if ftype == TType.I64:
26413 
          self.source = iprot.readI64();
26414 
        else:
26415 
          iprot.skip(ftype)
9776 vikram.rag 26416 
      else:
26417 
        iprot.skip(ftype)
26418 
      iprot.readFieldEnd()
26419 
    iprot.readStructEnd()
26420 
 
26421 
  def write(self, oprot):
26422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26424 
      return
26425 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
26426 
    if self.skulist is not None:
26427 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
26428 
      oprot.writeListBegin(TType.I64, len(self.skulist))
26429 
      for iter568 in self.skulist:
26430 
        oprot.writeI64(iter568)
26431 
      oprot.writeListEnd()
26432 
      oprot.writeFieldEnd()
26433 
    if self.timestamp is not None:
26434 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
26435 
      oprot.writeI64(self.timestamp)
26436 
      oprot.writeFieldEnd()
9816 kshitij.so 26437 
    if self.source is not None:
26438 
      oprot.writeFieldBegin('source', TType.I64, 3)
26439 
      oprot.writeI64(self.source)
26440 
      oprot.writeFieldEnd()
9776 vikram.rag 26441 
    oprot.writeFieldStop()
26442 
    oprot.writeStructEnd()
26443 
 
26444 
  def validate(self):
26445 
    return
26446 
 
26447 
 
26448 
  def __repr__(self):
26449 
    L = ['%s=%r' % (key, value)
26450 
      for key, value in self.__dict__.iteritems()]
26451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26452 
 
26453 
  def __eq__(self, other):
26454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26455 
 
26456 
  def __ne__(self, other):
26457 
    return not (self == other)
26458 
 
26459 
class updateMarketPlacePriceUpdateStatus_result:
26460 
 
26461 
  thrift_spec = (
26462 
  )
26463 
 
26464 
  def read(self, iprot):
26465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26467 
      return
26468 
    iprot.readStructBegin()
26469 
    while True:
26470 
      (fname, ftype, fid) = iprot.readFieldBegin()
26471 
      if ftype == TType.STOP:
26472 
        break
26473 
      else:
26474 
        iprot.skip(ftype)
26475 
      iprot.readFieldEnd()
26476 
    iprot.readStructEnd()
26477 
 
26478 
  def write(self, oprot):
26479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26481 
      return
26482 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
26483 
    oprot.writeFieldStop()
26484 
    oprot.writeStructEnd()
26485 
 
26486 
  def validate(self):
26487 
    return
26488 
 
26489 
 
26490 
  def __repr__(self):
26491 
    L = ['%s=%r' % (key, value)
26492 
      for key, value in self.__dict__.iteritems()]
26493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26494 
 
26495 
  def __eq__(self, other):
26496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26497 
 
26498 
  def __ne__(self, other):
26499 
    return not (self == other)
9861 rajveer 26500 
 
26501 
class updateItemHoldInventory_args:
26502 
  """
26503 
  Attributes:
26504 
   - itemHoldMap
26505 
  """
26506 
 
26507 
  thrift_spec = (
26508 
    None, # 0
26509 
    (1, TType.MAP, 'itemHoldMap', (TType.I64,None,TType.I64,None), None, ), # 1
26510 
  )
26511 
 
26512 
  def __init__(self, itemHoldMap=None,):
26513 
    self.itemHoldMap = itemHoldMap
26514 
 
26515 
  def read(self, iprot):
26516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26518 
      return
26519 
    iprot.readStructBegin()
26520 
    while True:
26521 
      (fname, ftype, fid) = iprot.readFieldBegin()
26522 
      if ftype == TType.STOP:
26523 
        break
26524 
      if fid == 1:
26525 
        if ftype == TType.MAP:
26526 
          self.itemHoldMap = {}
26527 
          (_ktype570, _vtype571, _size569 ) = iprot.readMapBegin()
26528 
          for _i573 in xrange(_size569):
26529 
            _key574 = iprot.readI64();
26530 
            _val575 = iprot.readI64();
26531 
            self.itemHoldMap[_key574] = _val575
26532 
          iprot.readMapEnd()
26533 
        else:
26534 
          iprot.skip(ftype)
26535 
      else:
26536 
        iprot.skip(ftype)
26537 
      iprot.readFieldEnd()
26538 
    iprot.readStructEnd()
26539 
 
26540 
  def write(self, oprot):
26541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26543 
      return
26544 
    oprot.writeStructBegin('updateItemHoldInventory_args')
26545 
    if self.itemHoldMap is not None:
26546 
      oprot.writeFieldBegin('itemHoldMap', TType.MAP, 1)
26547 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemHoldMap))
26548 
      for kiter576,viter577 in self.itemHoldMap.items():
26549 
        oprot.writeI64(kiter576)
26550 
        oprot.writeI64(viter577)
26551 
      oprot.writeMapEnd()
26552 
      oprot.writeFieldEnd()
26553 
    oprot.writeFieldStop()
26554 
    oprot.writeStructEnd()
26555 
 
26556 
  def validate(self):
26557 
    return
26558 
 
26559 
 
26560 
  def __repr__(self):
26561 
    L = ['%s=%r' % (key, value)
26562 
      for key, value in self.__dict__.iteritems()]
26563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26564 
 
26565 
  def __eq__(self, other):
26566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26567 
 
26568 
  def __ne__(self, other):
26569 
    return not (self == other)
26570 
 
26571 
class updateItemHoldInventory_result:
26572 
 
26573 
  thrift_spec = (
26574 
  )
26575 
 
26576 
  def read(self, iprot):
26577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26579 
      return
26580 
    iprot.readStructBegin()
26581 
    while True:
26582 
      (fname, ftype, fid) = iprot.readFieldBegin()
26583 
      if ftype == TType.STOP:
26584 
        break
26585 
      else:
26586 
        iprot.skip(ftype)
26587 
      iprot.readFieldEnd()
26588 
    iprot.readStructEnd()
26589 
 
26590 
  def write(self, oprot):
26591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26593 
      return
26594 
    oprot.writeStructBegin('updateItemHoldInventory_result')
26595 
    oprot.writeFieldStop()
26596 
    oprot.writeStructEnd()
26597 
 
26598 
  def validate(self):
26599 
    return
26600 
 
26601 
 
26602 
  def __repr__(self):
26603 
    L = ['%s=%r' % (key, value)
26604 
      for key, value in self.__dict__.iteritems()]
26605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26606 
 
26607 
  def __eq__(self, other):
26608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26609 
 
26610 
  def __ne__(self, other):
26611 
    return not (self == other)
9895 vikram.rag 26612 
 
26613 
class updateNlcAtMarketplaces_args:
26614 
  """
26615 
  Attributes:
26616 
   - item_id
26617 
   - vendor_id
26618 
   - nlc
26619 
  """
26620 
 
26621 
  thrift_spec = None
26622 
  def __init__(self, item_id=None, vendor_id=None, nlc=None,):
26623 
    self.item_id = item_id
26624 
    self.vendor_id = vendor_id
26625 
    self.nlc = nlc
26626 
 
26627 
  def read(self, iprot):
26628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26630 
      return
26631 
    iprot.readStructBegin()
26632 
    while True:
26633 
      (fname, ftype, fid) = iprot.readFieldBegin()
26634 
      if ftype == TType.STOP:
26635 
        break
26636 
      if fid == 1:
26637 
        if ftype == TType.I64:
26638 
          self.item_id = iprot.readI64();
26639 
        else:
26640 
          iprot.skip(ftype)
26641 
      elif fid == 2:
26642 
        if ftype == TType.I64:
26643 
          self.vendor_id = iprot.readI64();
26644 
        else:
26645 
          iprot.skip(ftype)
26646 
      elif fid == -1:
26647 
        if ftype == TType.DOUBLE:
26648 
          self.nlc = iprot.readDouble();
26649 
        else:
26650 
          iprot.skip(ftype)
26651 
      else:
26652 
        iprot.skip(ftype)
26653 
      iprot.readFieldEnd()
26654 
    iprot.readStructEnd()
26655 
 
26656 
  def write(self, oprot):
26657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26659 
      return
26660 
    oprot.writeStructBegin('updateNlcAtMarketplaces_args')
26661 
    if self.nlc is not None:
26662 
      oprot.writeFieldBegin('nlc', TType.DOUBLE, -1)
26663 
      oprot.writeDouble(self.nlc)
26664 
      oprot.writeFieldEnd()
26665 
    if self.item_id is not None:
26666 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26667 
      oprot.writeI64(self.item_id)
26668 
      oprot.writeFieldEnd()
26669 
    if self.vendor_id is not None:
26670 
      oprot.writeFieldBegin('vendor_id', TType.I64, 2)
26671 
      oprot.writeI64(self.vendor_id)
26672 
      oprot.writeFieldEnd()
26673 
    oprot.writeFieldStop()
26674 
    oprot.writeStructEnd()
26675 
 
26676 
  def validate(self):
26677 
    return
26678 
 
26679 
 
26680 
  def __repr__(self):
26681 
    L = ['%s=%r' % (key, value)
26682 
      for key, value in self.__dict__.iteritems()]
26683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26684 
 
26685 
  def __eq__(self, other):
26686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26687 
 
26688 
  def __ne__(self, other):
26689 
    return not (self == other)
26690 
 
26691 
class updateNlcAtMarketplaces_result:
26692 
 
26693 
  thrift_spec = (
26694 
  )
26695 
 
26696 
  def read(self, iprot):
26697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26699 
      return
26700 
    iprot.readStructBegin()
26701 
    while True:
26702 
      (fname, ftype, fid) = iprot.readFieldBegin()
26703 
      if ftype == TType.STOP:
26704 
        break
26705 
      else:
26706 
        iprot.skip(ftype)
26707 
      iprot.readFieldEnd()
26708 
    iprot.readStructEnd()
26709 
 
26710 
  def write(self, oprot):
26711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26713 
      return
26714 
    oprot.writeStructBegin('updateNlcAtMarketplaces_result')
26715 
    oprot.writeFieldStop()
26716 
    oprot.writeStructEnd()
26717 
 
26718 
  def validate(self):
26719 
    return
26720 
 
26721 
 
26722 
  def __repr__(self):
26723 
    L = ['%s=%r' % (key, value)
26724 
      for key, value in self.__dict__.iteritems()]
26725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26726 
 
26727 
  def __eq__(self, other):
26728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26729 
 
26730 
  def __ne__(self, other):
26731 
    return not (self == other)
9945 vikram.rag 26732 
 
26733 
class getAllFlipkartItems_args:
26734 
 
26735 
  thrift_spec = (
26736 
  )
26737 
 
26738 
  def read(self, iprot):
26739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26741 
      return
26742 
    iprot.readStructBegin()
26743 
    while True:
26744 
      (fname, ftype, fid) = iprot.readFieldBegin()
26745 
      if ftype == TType.STOP:
26746 
        break
26747 
      else:
26748 
        iprot.skip(ftype)
26749 
      iprot.readFieldEnd()
26750 
    iprot.readStructEnd()
26751 
 
26752 
  def write(self, oprot):
26753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26755 
      return
26756 
    oprot.writeStructBegin('getAllFlipkartItems_args')
26757 
    oprot.writeFieldStop()
26758 
    oprot.writeStructEnd()
26759 
 
26760 
  def validate(self):
26761 
    return
26762 
 
26763 
 
26764 
  def __repr__(self):
26765 
    L = ['%s=%r' % (key, value)
26766 
      for key, value in self.__dict__.iteritems()]
26767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26768 
 
26769 
  def __eq__(self, other):
26770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26771 
 
26772 
  def __ne__(self, other):
26773 
    return not (self == other)
26774 
 
26775 
class getAllFlipkartItems_result:
26776 
  """
26777 
  Attributes:
26778 
   - success
26779 
  """
26780 
 
26781 
  thrift_spec = (
26782 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
26783 
  )
26784 
 
26785 
  def __init__(self, success=None,):
26786 
    self.success = success
26787 
 
26788 
  def read(self, iprot):
26789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26791 
      return
26792 
    iprot.readStructBegin()
26793 
    while True:
26794 
      (fname, ftype, fid) = iprot.readFieldBegin()
26795 
      if ftype == TType.STOP:
26796 
        break
26797 
      if fid == 0:
26798 
        if ftype == TType.LIST:
26799 
          self.success = []
26800 
          (_etype581, _size578) = iprot.readListBegin()
26801 
          for _i582 in xrange(_size578):
26802 
            _elem583 = FlipkartItem()
26803 
            _elem583.read(iprot)
26804 
            self.success.append(_elem583)
26805 
          iprot.readListEnd()
26806 
        else:
26807 
          iprot.skip(ftype)
26808 
      else:
26809 
        iprot.skip(ftype)
26810 
      iprot.readFieldEnd()
26811 
    iprot.readStructEnd()
26812 
 
26813 
  def write(self, oprot):
26814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26816 
      return
26817 
    oprot.writeStructBegin('getAllFlipkartItems_result')
26818 
    if self.success is not None:
26819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26820 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26821 
      for iter584 in self.success:
26822 
        iter584.write(oprot)
26823 
      oprot.writeListEnd()
26824 
      oprot.writeFieldEnd()
26825 
    oprot.writeFieldStop()
26826 
    oprot.writeStructEnd()
26827 
 
26828 
  def validate(self):
26829 
    return
26830 
 
26831 
 
26832 
  def __repr__(self):
26833 
    L = ['%s=%r' % (key, value)
26834 
      for key, value in self.__dict__.iteritems()]
26835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26836 
 
26837 
  def __eq__(self, other):
26838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26839 
 
26840 
  def __ne__(self, other):
26841 
    return not (self == other)
10097 kshitij.so 26842 
 
26843 
class addOrUpdateFlipkartItem_args:
26844 
  """
26845 
  Attributes:
26846 
   - flipkartitem
26847 
  """
26848 
 
26849 
  thrift_spec = None
26850 
  def __init__(self, flipkartitem=None,):
26851 
    self.flipkartitem = flipkartitem
26852 
 
26853 
  def read(self, iprot):
26854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26856 
      return
26857 
    iprot.readStructBegin()
26858 
    while True:
26859 
      (fname, ftype, fid) = iprot.readFieldBegin()
26860 
      if ftype == TType.STOP:
26861 
        break
26862 
      if fid == -1:
26863 
        if ftype == TType.STRUCT:
26864 
          self.flipkartitem = FlipkartItem()
26865 
          self.flipkartitem.read(iprot)
26866 
        else:
26867 
          iprot.skip(ftype)
26868 
      else:
26869 
        iprot.skip(ftype)
26870 
      iprot.readFieldEnd()
26871 
    iprot.readStructEnd()
26872 
 
26873 
  def write(self, oprot):
26874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26876 
      return
26877 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_args')
26878 
    if self.flipkartitem is not None:
26879 
      oprot.writeFieldBegin('flipkartitem', TType.STRUCT, -1)
26880 
      self.flipkartitem.write(oprot)
26881 
      oprot.writeFieldEnd()
26882 
    oprot.writeFieldStop()
26883 
    oprot.writeStructEnd()
26884 
 
26885 
  def validate(self):
26886 
    return
26887 
 
26888 
 
26889 
  def __repr__(self):
26890 
    L = ['%s=%r' % (key, value)
26891 
      for key, value in self.__dict__.iteritems()]
26892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26893 
 
26894 
  def __eq__(self, other):
26895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26896 
 
26897 
  def __ne__(self, other):
26898 
    return not (self == other)
26899 
 
26900 
class addOrUpdateFlipkartItem_result:
26901 
  """
26902 
  Attributes:
26903 
   - success
26904 
  """
26905 
 
26906 
  thrift_spec = (
26907 
    (0, TType.BOOL, 'success', None, None, ), # 0
26908 
  )
26909 
 
26910 
  def __init__(self, success=None,):
26911 
    self.success = success
26912 
 
26913 
  def read(self, iprot):
26914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26916 
      return
26917 
    iprot.readStructBegin()
26918 
    while True:
26919 
      (fname, ftype, fid) = iprot.readFieldBegin()
26920 
      if ftype == TType.STOP:
26921 
        break
26922 
      if fid == 0:
26923 
        if ftype == TType.BOOL:
26924 
          self.success = iprot.readBool();
26925 
        else:
26926 
          iprot.skip(ftype)
26927 
      else:
26928 
        iprot.skip(ftype)
26929 
      iprot.readFieldEnd()
26930 
    iprot.readStructEnd()
26931 
 
26932 
  def write(self, oprot):
26933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26935 
      return
26936 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_result')
26937 
    if self.success is not None:
26938 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26939 
      oprot.writeBool(self.success)
26940 
      oprot.writeFieldEnd()
26941 
    oprot.writeFieldStop()
26942 
    oprot.writeStructEnd()
26943 
 
26944 
  def validate(self):
26945 
    return
26946 
 
26947 
 
26948 
  def __repr__(self):
26949 
    L = ['%s=%r' % (key, value)
26950 
      for key, value in self.__dict__.iteritems()]
26951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26952 
 
26953 
  def __eq__(self, other):
26954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26955 
 
26956 
  def __ne__(self, other):
26957 
    return not (self == other)
26958 
 
26959 
class getFlipkartItem_args:
26960 
  """
26961 
  Attributes:
26962 
   - item_id
26963 
  """
26964 
 
26965 
  thrift_spec = (
26966 
    None, # 0
26967 
    (1, TType.I64, 'item_id', None, None, ), # 1
26968 
  )
26969 
 
26970 
  def __init__(self, item_id=None,):
26971 
    self.item_id = item_id
26972 
 
26973 
  def read(self, iprot):
26974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26976 
      return
26977 
    iprot.readStructBegin()
26978 
    while True:
26979 
      (fname, ftype, fid) = iprot.readFieldBegin()
26980 
      if ftype == TType.STOP:
26981 
        break
26982 
      if fid == 1:
26983 
        if ftype == TType.I64:
26984 
          self.item_id = iprot.readI64();
26985 
        else:
26986 
          iprot.skip(ftype)
26987 
      else:
26988 
        iprot.skip(ftype)
26989 
      iprot.readFieldEnd()
26990 
    iprot.readStructEnd()
26991 
 
26992 
  def write(self, oprot):
26993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26995 
      return
26996 
    oprot.writeStructBegin('getFlipkartItem_args')
26997 
    if self.item_id is not None:
26998 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26999 
      oprot.writeI64(self.item_id)
27000 
      oprot.writeFieldEnd()
27001 
    oprot.writeFieldStop()
27002 
    oprot.writeStructEnd()
27003 
 
27004 
  def validate(self):
27005 
    return
27006 
 
27007 
 
27008 
  def __repr__(self):
27009 
    L = ['%s=%r' % (key, value)
27010 
      for key, value in self.__dict__.iteritems()]
27011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27012 
 
27013 
  def __eq__(self, other):
27014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27015 
 
27016 
  def __ne__(self, other):
27017 
    return not (self == other)
27018 
 
27019 
class getFlipkartItem_result:
27020 
  """
27021 
  Attributes:
27022 
   - success
27023 
  """
27024 
 
27025 
  thrift_spec = (
27026 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
27027 
  )
27028 
 
27029 
  def __init__(self, success=None,):
27030 
    self.success = success
27031 
 
27032 
  def read(self, iprot):
27033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27035 
      return
27036 
    iprot.readStructBegin()
27037 
    while True:
27038 
      (fname, ftype, fid) = iprot.readFieldBegin()
27039 
      if ftype == TType.STOP:
27040 
        break
27041 
      if fid == 0:
27042 
        if ftype == TType.STRUCT:
27043 
          self.success = FlipkartItem()
27044 
          self.success.read(iprot)
27045 
        else:
27046 
          iprot.skip(ftype)
27047 
      else:
27048 
        iprot.skip(ftype)
27049 
      iprot.readFieldEnd()
27050 
    iprot.readStructEnd()
27051 
 
27052 
  def write(self, oprot):
27053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27055 
      return
27056 
    oprot.writeStructBegin('getFlipkartItem_result')
27057 
    if self.success is not None:
27058 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27059 
      self.success.write(oprot)
27060 
      oprot.writeFieldEnd()
27061 
    oprot.writeFieldStop()
27062 
    oprot.writeStructEnd()
27063 
 
27064 
  def validate(self):
27065 
    return
27066 
 
27067 
 
27068 
  def __repr__(self):
27069 
    L = ['%s=%r' % (key, value)
27070 
      for key, value in self.__dict__.iteritems()]
27071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27072 
 
27073 
  def __eq__(self, other):
27074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27075 
 
27076 
  def __ne__(self, other):
27077 
    return not (self == other)
27078 
 
27079 
class getFlipkartItemDetails_args:
27080 
  """
27081 
  Attributes:
27082 
   - item_id
27083 
  """
27084 
 
27085 
  thrift_spec = (
27086 
    None, # 0
27087 
    (1, TType.I64, 'item_id', None, None, ), # 1
27088 
  )
27089 
 
27090 
  def __init__(self, item_id=None,):
27091 
    self.item_id = item_id
27092 
 
27093 
  def read(self, iprot):
27094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27096 
      return
27097 
    iprot.readStructBegin()
27098 
    while True:
27099 
      (fname, ftype, fid) = iprot.readFieldBegin()
27100 
      if ftype == TType.STOP:
27101 
        break
27102 
      if fid == 1:
27103 
        if ftype == TType.I64:
27104 
          self.item_id = iprot.readI64();
27105 
        else:
27106 
          iprot.skip(ftype)
27107 
      else:
27108 
        iprot.skip(ftype)
27109 
      iprot.readFieldEnd()
27110 
    iprot.readStructEnd()
27111 
 
27112 
  def write(self, oprot):
27113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27115 
      return
27116 
    oprot.writeStructBegin('getFlipkartItemDetails_args')
27117 
    if self.item_id is not None:
27118 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
27119 
      oprot.writeI64(self.item_id)
27120 
      oprot.writeFieldEnd()
27121 
    oprot.writeFieldStop()
27122 
    oprot.writeStructEnd()
27123 
 
27124 
  def validate(self):
27125 
    return
27126 
 
27127 
 
27128 
  def __repr__(self):
27129 
    L = ['%s=%r' % (key, value)
27130 
      for key, value in self.__dict__.iteritems()]
27131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27132 
 
27133 
  def __eq__(self, other):
27134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27135 
 
27136 
  def __ne__(self, other):
27137 
    return not (self == other)
27138 
 
27139 
class getFlipkartItemDetails_result:
27140 
  """
27141 
  Attributes:
27142 
   - success
27143 
  """
27144 
 
27145 
  thrift_spec = (
27146 
    (0, TType.STRUCT, 'success', (FlipkartItemDetails, FlipkartItemDetails.thrift_spec), None, ), # 0
27147 
  )
27148 
 
27149 
  def __init__(self, success=None,):
27150 
    self.success = success
27151 
 
27152 
  def read(self, iprot):
27153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27155 
      return
27156 
    iprot.readStructBegin()
27157 
    while True:
27158 
      (fname, ftype, fid) = iprot.readFieldBegin()
27159 
      if ftype == TType.STOP:
27160 
        break
27161 
      if fid == 0:
27162 
        if ftype == TType.STRUCT:
27163 
          self.success = FlipkartItemDetails()
27164 
          self.success.read(iprot)
27165 
        else:
27166 
          iprot.skip(ftype)
27167 
      else:
27168 
        iprot.skip(ftype)
27169 
      iprot.readFieldEnd()
27170 
    iprot.readStructEnd()
27171 
 
27172 
  def write(self, oprot):
27173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27175 
      return
27176 
    oprot.writeStructBegin('getFlipkartItemDetails_result')
27177 
    if self.success is not None:
27178 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27179 
      self.success.write(oprot)
27180 
      oprot.writeFieldEnd()
27181 
    oprot.writeFieldStop()
27182 
    oprot.writeStructEnd()
27183 
 
27184 
  def validate(self):
27185 
    return
27186 
 
27187 
 
27188 
  def __repr__(self):
27189 
    L = ['%s=%r' % (key, value)
27190 
      for key, value in self.__dict__.iteritems()]
27191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27192 
 
27193 
  def __eq__(self, other):
27194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27195 
 
27196 
  def __ne__(self, other):
27197 
    return not (self == other)
27198 
 
27199 
class getFlipkartItems_args:
27200 
  """
27201 
  Attributes:
27202 
   - offset
27203 
   - limit
27204 
  """
27205 
 
27206 
  thrift_spec = (
27207 
    None, # 0
27208 
    (1, TType.I64, 'offset', None, None, ), # 1
27209 
    (2, TType.I64, 'limit', None, None, ), # 2
27210 
  )
27211 
 
27212 
  def __init__(self, offset=None, limit=None,):
27213 
    self.offset = offset
27214 
    self.limit = limit
27215 
 
27216 
  def read(self, iprot):
27217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27219 
      return
27220 
    iprot.readStructBegin()
27221 
    while True:
27222 
      (fname, ftype, fid) = iprot.readFieldBegin()
27223 
      if ftype == TType.STOP:
27224 
        break
27225 
      if fid == 1:
27226 
        if ftype == TType.I64:
27227 
          self.offset = iprot.readI64();
27228 
        else:
27229 
          iprot.skip(ftype)
27230 
      elif fid == 2:
27231 
        if ftype == TType.I64:
27232 
          self.limit = iprot.readI64();
27233 
        else:
27234 
          iprot.skip(ftype)
27235 
      else:
27236 
        iprot.skip(ftype)
27237 
      iprot.readFieldEnd()
27238 
    iprot.readStructEnd()
27239 
 
27240 
  def write(self, oprot):
27241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27243 
      return
27244 
    oprot.writeStructBegin('getFlipkartItems_args')
27245 
    if self.offset is not None:
27246 
      oprot.writeFieldBegin('offset', TType.I64, 1)
27247 
      oprot.writeI64(self.offset)
27248 
      oprot.writeFieldEnd()
27249 
    if self.limit is not None:
27250 
      oprot.writeFieldBegin('limit', TType.I64, 2)
27251 
      oprot.writeI64(self.limit)
27252 
      oprot.writeFieldEnd()
27253 
    oprot.writeFieldStop()
27254 
    oprot.writeStructEnd()
27255 
 
27256 
  def validate(self):
27257 
    return
27258 
 
27259 
 
27260 
  def __repr__(self):
27261 
    L = ['%s=%r' % (key, value)
27262 
      for key, value in self.__dict__.iteritems()]
27263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27264 
 
27265 
  def __eq__(self, other):
27266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27267 
 
27268 
  def __ne__(self, other):
27269 
    return not (self == other)
27270 
 
27271 
class getFlipkartItems_result:
27272 
  """
27273 
  Attributes:
27274 
   - success
27275 
  """
27276 
 
27277 
  thrift_spec = (
27278 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27279 
  )
27280 
 
27281 
  def __init__(self, success=None,):
27282 
    self.success = success
27283 
 
27284 
  def read(self, iprot):
27285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27287 
      return
27288 
    iprot.readStructBegin()
27289 
    while True:
27290 
      (fname, ftype, fid) = iprot.readFieldBegin()
27291 
      if ftype == TType.STOP:
27292 
        break
27293 
      if fid == 0:
27294 
        if ftype == TType.LIST:
27295 
          self.success = []
27296 
          (_etype588, _size585) = iprot.readListBegin()
27297 
          for _i589 in xrange(_size585):
27298 
            _elem590 = FlipkartItemDetails()
27299 
            _elem590.read(iprot)
27300 
            self.success.append(_elem590)
27301 
          iprot.readListEnd()
27302 
        else:
27303 
          iprot.skip(ftype)
27304 
      else:
27305 
        iprot.skip(ftype)
27306 
      iprot.readFieldEnd()
27307 
    iprot.readStructEnd()
27308 
 
27309 
  def write(self, oprot):
27310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27312 
      return
27313 
    oprot.writeStructBegin('getFlipkartItems_result')
27314 
    if self.success is not None:
27315 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27316 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27317 
      for iter591 in self.success:
27318 
        iter591.write(oprot)
27319 
      oprot.writeListEnd()
27320 
      oprot.writeFieldEnd()
27321 
    oprot.writeFieldStop()
27322 
    oprot.writeStructEnd()
27323 
 
27324 
  def validate(self):
27325 
    return
27326 
 
27327 
 
27328 
  def __repr__(self):
27329 
    L = ['%s=%r' % (key, value)
27330 
      for key, value in self.__dict__.iteritems()]
27331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27332 
 
27333 
  def __eq__(self, other):
27334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27335 
 
27336 
  def __ne__(self, other):
27337 
    return not (self == other)
27338 
 
27339 
class searchFlipkartItems_args:
27340 
  """
27341 
  Attributes:
27342 
   - searchTerm
27343 
   - offset
27344 
   - limit
27345 
  """
27346 
 
27347 
  thrift_spec = (
27348 
    None, # 0
27349 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
27350 
    (2, TType.I64, 'offset', None, None, ), # 2
27351 
    (3, TType.I64, 'limit', None, None, ), # 3
27352 
  )
27353 
 
27354 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
27355 
    self.searchTerm = searchTerm
27356 
    self.offset = offset
27357 
    self.limit = limit
27358 
 
27359 
  def read(self, iprot):
27360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27362 
      return
27363 
    iprot.readStructBegin()
27364 
    while True:
27365 
      (fname, ftype, fid) = iprot.readFieldBegin()
27366 
      if ftype == TType.STOP:
27367 
        break
27368 
      if fid == 1:
27369 
        if ftype == TType.LIST:
27370 
          self.searchTerm = []
27371 
          (_etype595, _size592) = iprot.readListBegin()
27372 
          for _i596 in xrange(_size592):
27373 
            _elem597 = iprot.readString();
27374 
            self.searchTerm.append(_elem597)
27375 
          iprot.readListEnd()
27376 
        else:
27377 
          iprot.skip(ftype)
27378 
      elif fid == 2:
27379 
        if ftype == TType.I64:
27380 
          self.offset = iprot.readI64();
27381 
        else:
27382 
          iprot.skip(ftype)
27383 
      elif fid == 3:
27384 
        if ftype == TType.I64:
27385 
          self.limit = iprot.readI64();
27386 
        else:
27387 
          iprot.skip(ftype)
27388 
      else:
27389 
        iprot.skip(ftype)
27390 
      iprot.readFieldEnd()
27391 
    iprot.readStructEnd()
27392 
 
27393 
  def write(self, oprot):
27394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27396 
      return
27397 
    oprot.writeStructBegin('searchFlipkartItems_args')
27398 
    if self.searchTerm is not None:
27399 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
27400 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
27401 
      for iter598 in self.searchTerm:
27402 
        oprot.writeString(iter598)
27403 
      oprot.writeListEnd()
27404 
      oprot.writeFieldEnd()
27405 
    if self.offset is not None:
27406 
      oprot.writeFieldBegin('offset', TType.I64, 2)
27407 
      oprot.writeI64(self.offset)
27408 
      oprot.writeFieldEnd()
27409 
    if self.limit is not None:
27410 
      oprot.writeFieldBegin('limit', TType.I64, 3)
27411 
      oprot.writeI64(self.limit)
27412 
      oprot.writeFieldEnd()
27413 
    oprot.writeFieldStop()
27414 
    oprot.writeStructEnd()
27415 
 
27416 
  def validate(self):
27417 
    return
27418 
 
27419 
 
27420 
  def __repr__(self):
27421 
    L = ['%s=%r' % (key, value)
27422 
      for key, value in self.__dict__.iteritems()]
27423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27424 
 
27425 
  def __eq__(self, other):
27426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27427 
 
27428 
  def __ne__(self, other):
27429 
    return not (self == other)
27430 
 
27431 
class searchFlipkartItems_result:
27432 
  """
27433 
  Attributes:
27434 
   - success
27435 
  """
27436 
 
27437 
  thrift_spec = (
27438 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27439 
  )
27440 
 
27441 
  def __init__(self, success=None,):
27442 
    self.success = success
27443 
 
27444 
  def read(self, iprot):
27445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27447 
      return
27448 
    iprot.readStructBegin()
27449 
    while True:
27450 
      (fname, ftype, fid) = iprot.readFieldBegin()
27451 
      if ftype == TType.STOP:
27452 
        break
27453 
      if fid == 0:
27454 
        if ftype == TType.LIST:
27455 
          self.success = []
27456 
          (_etype602, _size599) = iprot.readListBegin()
27457 
          for _i603 in xrange(_size599):
27458 
            _elem604 = FlipkartItemDetails()
27459 
            _elem604.read(iprot)
27460 
            self.success.append(_elem604)
27461 
          iprot.readListEnd()
27462 
        else:
27463 
          iprot.skip(ftype)
27464 
      else:
27465 
        iprot.skip(ftype)
27466 
      iprot.readFieldEnd()
27467 
    iprot.readStructEnd()
27468 
 
27469 
  def write(self, oprot):
27470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27472 
      return
27473 
    oprot.writeStructBegin('searchFlipkartItems_result')
27474 
    if self.success is not None:
27475 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27476 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27477 
      for iter605 in self.success:
27478 
        iter605.write(oprot)
27479 
      oprot.writeListEnd()
27480 
      oprot.writeFieldEnd()
27481 
    oprot.writeFieldStop()
27482 
    oprot.writeStructEnd()
27483 
 
27484 
  def validate(self):
27485 
    return
27486 
 
27487 
 
27488 
  def __repr__(self):
27489 
    L = ['%s=%r' % (key, value)
27490 
      for key, value in self.__dict__.iteritems()]
27491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27492 
 
27493 
  def __eq__(self, other):
27494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27495 
 
27496 
  def __ne__(self, other):
27497 
    return not (self == other)
27498 
 
27499 
class getCountForFlipkartItems_args:
27500 
 
27501 
  thrift_spec = (
27502 
  )
27503 
 
27504 
  def read(self, iprot):
27505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27507 
      return
27508 
    iprot.readStructBegin()
27509 
    while True:
27510 
      (fname, ftype, fid) = iprot.readFieldBegin()
27511 
      if ftype == TType.STOP:
27512 
        break
27513 
      else:
27514 
        iprot.skip(ftype)
27515 
      iprot.readFieldEnd()
27516 
    iprot.readStructEnd()
27517 
 
27518 
  def write(self, oprot):
27519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27521 
      return
27522 
    oprot.writeStructBegin('getCountForFlipkartItems_args')
27523 
    oprot.writeFieldStop()
27524 
    oprot.writeStructEnd()
27525 
 
27526 
  def validate(self):
27527 
    return
27528 
 
27529 
 
27530 
  def __repr__(self):
27531 
    L = ['%s=%r' % (key, value)
27532 
      for key, value in self.__dict__.iteritems()]
27533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27534 
 
27535 
  def __eq__(self, other):
27536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27537 
 
27538 
  def __ne__(self, other):
27539 
    return not (self == other)
27540 
 
27541 
class getCountForFlipkartItems_result:
27542 
  """
27543 
  Attributes:
27544 
   - success
27545 
  """
27546 
 
27547 
  thrift_spec = (
27548 
    (0, TType.I64, 'success', None, None, ), # 0
27549 
  )
27550 
 
27551 
  def __init__(self, success=None,):
27552 
    self.success = success
27553 
 
27554 
  def read(self, iprot):
27555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27557 
      return
27558 
    iprot.readStructBegin()
27559 
    while True:
27560 
      (fname, ftype, fid) = iprot.readFieldBegin()
27561 
      if ftype == TType.STOP:
27562 
        break
27563 
      if fid == 0:
27564 
        if ftype == TType.I64:
27565 
          self.success = iprot.readI64();
27566 
        else:
27567 
          iprot.skip(ftype)
27568 
      else:
27569 
        iprot.skip(ftype)
27570 
      iprot.readFieldEnd()
27571 
    iprot.readStructEnd()
27572 
 
27573 
  def write(self, oprot):
27574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27576 
      return
27577 
    oprot.writeStructBegin('getCountForFlipkartItems_result')
27578 
    if self.success is not None:
27579 
      oprot.writeFieldBegin('success', TType.I64, 0)
27580 
      oprot.writeI64(self.success)
27581 
      oprot.writeFieldEnd()
27582 
    oprot.writeFieldStop()
27583 
    oprot.writeStructEnd()
27584 
 
27585 
  def validate(self):
27586 
    return
27587 
 
27588 
 
27589 
  def __repr__(self):
27590 
    L = ['%s=%r' % (key, value)
27591 
      for key, value in self.__dict__.iteritems()]
27592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27593 
 
27594 
  def __eq__(self, other):
27595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27596 
 
27597 
  def __ne__(self, other):
27598 
    return not (self == other)
27599 
 
27600 
class getFlipkartSearchResultCount_args:
27601 
  """
27602 
  Attributes:
27603 
   - searchTerm
27604 
  """
27605 
 
27606 
  thrift_spec = (
27607 
    None, # 0
27608 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
27609 
  )
27610 
 
27611 
  def __init__(self, searchTerm=None,):
27612 
    self.searchTerm = searchTerm
27613 
 
27614 
  def read(self, iprot):
27615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27617 
      return
27618 
    iprot.readStructBegin()
27619 
    while True:
27620 
      (fname, ftype, fid) = iprot.readFieldBegin()
27621 
      if ftype == TType.STOP:
27622 
        break
27623 
      if fid == 1:
27624 
        if ftype == TType.LIST:
27625 
          self.searchTerm = []
27626 
          (_etype609, _size606) = iprot.readListBegin()
27627 
          for _i610 in xrange(_size606):
27628 
            _elem611 = iprot.readString();
27629 
            self.searchTerm.append(_elem611)
27630 
          iprot.readListEnd()
27631 
        else:
27632 
          iprot.skip(ftype)
27633 
      else:
27634 
        iprot.skip(ftype)
27635 
      iprot.readFieldEnd()
27636 
    iprot.readStructEnd()
27637 
 
27638 
  def write(self, oprot):
27639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27641 
      return
27642 
    oprot.writeStructBegin('getFlipkartSearchResultCount_args')
27643 
    if self.searchTerm is not None:
27644 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
27645 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
27646 
      for iter612 in self.searchTerm:
27647 
        oprot.writeString(iter612)
27648 
      oprot.writeListEnd()
27649 
      oprot.writeFieldEnd()
27650 
    oprot.writeFieldStop()
27651 
    oprot.writeStructEnd()
27652 
 
27653 
  def validate(self):
27654 
    return
27655 
 
27656 
 
27657 
  def __repr__(self):
27658 
    L = ['%s=%r' % (key, value)
27659 
      for key, value in self.__dict__.iteritems()]
27660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27661 
 
27662 
  def __eq__(self, other):
27663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27664 
 
27665 
  def __ne__(self, other):
27666 
    return not (self == other)
27667 
 
27668 
class getFlipkartSearchResultCount_result:
27669 
  """
27670 
  Attributes:
27671 
   - success
27672 
  """
27673 
 
27674 
  thrift_spec = (
27675 
    (0, TType.I64, 'success', None, None, ), # 0
27676 
  )
27677 
 
27678 
  def __init__(self, success=None,):
27679 
    self.success = success
27680 
 
27681 
  def read(self, iprot):
27682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27684 
      return
27685 
    iprot.readStructBegin()
27686 
    while True:
27687 
      (fname, ftype, fid) = iprot.readFieldBegin()
27688 
      if ftype == TType.STOP:
27689 
        break
27690 
      if fid == 0:
27691 
        if ftype == TType.I64:
27692 
          self.success = iprot.readI64();
27693 
        else:
27694 
          iprot.skip(ftype)
27695 
      else:
27696 
        iprot.skip(ftype)
27697 
      iprot.readFieldEnd()
27698 
    iprot.readStructEnd()
27699 
 
27700 
  def write(self, oprot):
27701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27703 
      return
27704 
    oprot.writeStructBegin('getFlipkartSearchResultCount_result')
27705 
    if self.success is not None:
27706 
      oprot.writeFieldBegin('success', TType.I64, 0)
27707 
      oprot.writeI64(self.success)
27708 
      oprot.writeFieldEnd()
27709 
    oprot.writeFieldStop()
27710 
    oprot.writeStructEnd()
27711 
 
27712 
  def validate(self):
27713 
    return
27714 
 
27715 
 
27716 
  def __repr__(self):
27717 
    L = ['%s=%r' % (key, value)
27718 
      for key, value in self.__dict__.iteritems()]
27719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27720 
 
27721 
  def __eq__(self, other):
27722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27723 
 
27724 
  def __ne__(self, other):
27725 
    return not (self == other)
27726 
 
27727 
class getAllFkItems_args:
27728 
 
27729 
  thrift_spec = (
27730 
  )
27731 
 
27732 
  def read(self, iprot):
27733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27735 
      return
27736 
    iprot.readStructBegin()
27737 
    while True:
27738 
      (fname, ftype, fid) = iprot.readFieldBegin()
27739 
      if ftype == TType.STOP:
27740 
        break
27741 
      else:
27742 
        iprot.skip(ftype)
27743 
      iprot.readFieldEnd()
27744 
    iprot.readStructEnd()
27745 
 
27746 
  def write(self, oprot):
27747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27749 
      return
27750 
    oprot.writeStructBegin('getAllFkItems_args')
27751 
    oprot.writeFieldStop()
27752 
    oprot.writeStructEnd()
27753 
 
27754 
  def validate(self):
27755 
    return
27756 
 
27757 
 
27758 
  def __repr__(self):
27759 
    L = ['%s=%r' % (key, value)
27760 
      for key, value in self.__dict__.iteritems()]
27761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27762 
 
27763 
  def __eq__(self, other):
27764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27765 
 
27766 
  def __ne__(self, other):
27767 
    return not (self == other)
27768 
 
27769 
class getAllFkItems_result:
27770 
  """
27771 
  Attributes:
27772 
   - success
27773 
  """
27774 
 
27775 
  thrift_spec = (
27776 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27777 
  )
27778 
 
27779 
  def __init__(self, success=None,):
27780 
    self.success = success
27781 
 
27782 
  def read(self, iprot):
27783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27785 
      return
27786 
    iprot.readStructBegin()
27787 
    while True:
27788 
      (fname, ftype, fid) = iprot.readFieldBegin()
27789 
      if ftype == TType.STOP:
27790 
        break
27791 
      if fid == 0:
27792 
        if ftype == TType.LIST:
27793 
          self.success = []
27794 
          (_etype616, _size613) = iprot.readListBegin()
27795 
          for _i617 in xrange(_size613):
27796 
            _elem618 = FlipkartItemDetails()
27797 
            _elem618.read(iprot)
27798 
            self.success.append(_elem618)
27799 
          iprot.readListEnd()
27800 
        else:
27801 
          iprot.skip(ftype)
27802 
      else:
27803 
        iprot.skip(ftype)
27804 
      iprot.readFieldEnd()
27805 
    iprot.readStructEnd()
27806 
 
27807 
  def write(self, oprot):
27808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27810 
      return
27811 
    oprot.writeStructBegin('getAllFkItems_result')
27812 
    if self.success is not None:
27813 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27814 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27815 
      for iter619 in self.success:
27816 
        iter619.write(oprot)
27817 
      oprot.writeListEnd()
27818 
      oprot.writeFieldEnd()
27819 
    oprot.writeFieldStop()
27820 
    oprot.writeStructEnd()
27821 
 
27822 
  def validate(self):
27823 
    return
27824 
 
27825 
 
27826 
  def __repr__(self):
27827 
    L = ['%s=%r' % (key, value)
27828 
      for key, value in self.__dict__.iteritems()]
27829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27830 
 
27831 
  def __eq__(self, other):
27832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27833 
 
27834 
  def __ne__(self, other):
27835 
    return not (self == other)
10140 vikram.rag 27836 
 
27837 
class getFlipkartItemBySkyAtFlipkart_args:
27838 
  """
27839 
  Attributes:
27840 
   - sku
27841 
  """
27842 
 
11531 vikram.rag 27843 
  thrift_spec = None
10140 vikram.rag 27844 
  def __init__(self, sku=None,):
27845 
    self.sku = sku
27846 
 
27847 
  def read(self, iprot):
27848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27850 
      return
27851 
    iprot.readStructBegin()
27852 
    while True:
27853 
      (fname, ftype, fid) = iprot.readFieldBegin()
27854 
      if ftype == TType.STOP:
27855 
        break
11531 vikram.rag 27856 
      if fid == -1:
10140 vikram.rag 27857 
        if ftype == TType.STRING:
27858 
          self.sku = iprot.readString();
27859 
        else:
27860 
          iprot.skip(ftype)
27861 
      else:
27862 
        iprot.skip(ftype)
27863 
      iprot.readFieldEnd()
27864 
    iprot.readStructEnd()
27865 
 
27866 
  def write(self, oprot):
27867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27869 
      return
27870 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_args')
27871 
    if self.sku is not None:
11531 vikram.rag 27872 
      oprot.writeFieldBegin('sku', TType.STRING, -1)
10140 vikram.rag 27873 
      oprot.writeString(self.sku)
27874 
      oprot.writeFieldEnd()
27875 
    oprot.writeFieldStop()
27876 
    oprot.writeStructEnd()
27877 
 
27878 
  def validate(self):
27879 
    return
27880 
 
27881 
 
27882 
  def __repr__(self):
27883 
    L = ['%s=%r' % (key, value)
27884 
      for key, value in self.__dict__.iteritems()]
27885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27886 
 
27887 
  def __eq__(self, other):
27888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27889 
 
27890 
  def __ne__(self, other):
27891 
    return not (self == other)
27892 
 
27893 
class getFlipkartItemBySkyAtFlipkart_result:
27894 
  """
27895 
  Attributes:
27896 
   - success
27897 
  """
27898 
 
27899 
  thrift_spec = (
27900 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
27901 
  )
27902 
 
27903 
  def __init__(self, success=None,):
27904 
    self.success = success
27905 
 
27906 
  def read(self, iprot):
27907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27909 
      return
27910 
    iprot.readStructBegin()
27911 
    while True:
27912 
      (fname, ftype, fid) = iprot.readFieldBegin()
27913 
      if ftype == TType.STOP:
27914 
        break
27915 
      if fid == 0:
27916 
        if ftype == TType.STRUCT:
27917 
          self.success = FlipkartItem()
27918 
          self.success.read(iprot)
27919 
        else:
27920 
          iprot.skip(ftype)
27921 
      else:
27922 
        iprot.skip(ftype)
27923 
      iprot.readFieldEnd()
27924 
    iprot.readStructEnd()
27925 
 
27926 
  def write(self, oprot):
27927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27929 
      return
27930 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_result')
27931 
    if self.success is not None:
27932 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27933 
      self.success.write(oprot)
27934 
      oprot.writeFieldEnd()
27935 
    oprot.writeFieldStop()
27936 
    oprot.writeStructEnd()
27937 
 
27938 
  def validate(self):
27939 
    return
27940 
 
27941 
 
27942 
  def __repr__(self):
27943 
    L = ['%s=%r' % (key, value)
27944 
      for key, value in self.__dict__.iteritems()]
27945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27946 
 
27947 
  def __eq__(self, other):
27948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27949 
 
27950 
  def __ne__(self, other):
27951 
    return not (self == other)
10909 vikram.rag 27952 
 
11015 kshitij.so 27953 
class getMarketplaceHistory_args:
27954 
  """
27955 
  Attributes:
27956 
   - source
27957 
   - offset
27958 
   - itemId
27959 
  """
10909 vikram.rag 27960 
 
27961 
  thrift_spec = (
11015 kshitij.so 27962 
    None, # 0
27963 
    (1, TType.I64, 'source', None, None, ), # 1
27964 
    (2, TType.I64, 'offset', None, None, ), # 2
27965 
    (3, TType.I64, 'itemId', None, None, ), # 3
10909 vikram.rag 27966 
  )
27967 
 
11015 kshitij.so 27968 
  def __init__(self, source=None, offset=None, itemId=None,):
27969 
    self.source = source
27970 
    self.offset = offset
27971 
    self.itemId = itemId
27972 
 
10909 vikram.rag 27973 
  def read(self, iprot):
27974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27976 
      return
27977 
    iprot.readStructBegin()
27978 
    while True:
27979 
      (fname, ftype, fid) = iprot.readFieldBegin()
27980 
      if ftype == TType.STOP:
27981 
        break
11015 kshitij.so 27982 
      if fid == 1:
27983 
        if ftype == TType.I64:
27984 
          self.source = iprot.readI64();
27985 
        else:
27986 
          iprot.skip(ftype)
27987 
      elif fid == 2:
27988 
        if ftype == TType.I64:
27989 
          self.offset = iprot.readI64();
27990 
        else:
27991 
          iprot.skip(ftype)
27992 
      elif fid == 3:
27993 
        if ftype == TType.I64:
27994 
          self.itemId = iprot.readI64();
27995 
        else:
27996 
          iprot.skip(ftype)
10909 vikram.rag 27997 
      else:
27998 
        iprot.skip(ftype)
27999 
      iprot.readFieldEnd()
28000 
    iprot.readStructEnd()
28001 
 
28002 
  def write(self, oprot):
28003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28005 
      return
11015 kshitij.so 28006 
    oprot.writeStructBegin('getMarketplaceHistory_args')
28007 
    if self.source is not None:
28008 
      oprot.writeFieldBegin('source', TType.I64, 1)
28009 
      oprot.writeI64(self.source)
28010 
      oprot.writeFieldEnd()
28011 
    if self.offset is not None:
28012 
      oprot.writeFieldBegin('offset', TType.I64, 2)
28013 
      oprot.writeI64(self.offset)
28014 
      oprot.writeFieldEnd()
28015 
    if self.itemId is not None:
28016 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
28017 
      oprot.writeI64(self.itemId)
28018 
      oprot.writeFieldEnd()
10909 vikram.rag 28019 
    oprot.writeFieldStop()
28020 
    oprot.writeStructEnd()
28021 
 
28022 
  def validate(self):
28023 
    return
28024 
 
28025 
 
28026 
  def __repr__(self):
28027 
    L = ['%s=%r' % (key, value)
28028 
      for key, value in self.__dict__.iteritems()]
28029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28030 
 
28031 
  def __eq__(self, other):
28032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28033 
 
28034 
  def __ne__(self, other):
28035 
    return not (self == other)
28036 
 
11015 kshitij.so 28037 
class getMarketplaceHistory_result:
10909 vikram.rag 28038 
  """
28039 
  Attributes:
28040 
   - success
28041 
  """
28042 
 
28043 
  thrift_spec = (
11015 kshitij.so 28044 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
10909 vikram.rag 28045 
  )
28046 
 
28047 
  def __init__(self, success=None,):
28048 
    self.success = success
28049 
 
28050 
  def read(self, iprot):
28051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28053 
      return
28054 
    iprot.readStructBegin()
28055 
    while True:
28056 
      (fname, ftype, fid) = iprot.readFieldBegin()
28057 
      if ftype == TType.STOP:
28058 
        break
28059 
      if fid == 0:
28060 
        if ftype == TType.LIST:
28061 
          self.success = []
28062 
          (_etype623, _size620) = iprot.readListBegin()
28063 
          for _i624 in xrange(_size620):
11015 kshitij.so 28064 
            _elem625 = MarketplaceHistory()
10909 vikram.rag 28065 
            _elem625.read(iprot)
28066 
            self.success.append(_elem625)
28067 
          iprot.readListEnd()
28068 
        else:
28069 
          iprot.skip(ftype)
28070 
      else:
28071 
        iprot.skip(ftype)
28072 
      iprot.readFieldEnd()
28073 
    iprot.readStructEnd()
28074 
 
28075 
  def write(self, oprot):
28076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28078 
      return
11015 kshitij.so 28079 
    oprot.writeStructBegin('getMarketplaceHistory_result')
10909 vikram.rag 28080 
    if self.success is not None:
28081 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28082 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28083 
      for iter626 in self.success:
28084 
        iter626.write(oprot)
28085 
      oprot.writeListEnd()
28086 
      oprot.writeFieldEnd()
28087 
    oprot.writeFieldStop()
28088 
    oprot.writeStructEnd()
28089 
 
28090 
  def validate(self):
28091 
    return
28092 
 
28093 
 
28094 
  def __repr__(self):
28095 
    L = ['%s=%r' % (key, value)
28096 
      for key, value in self.__dict__.iteritems()]
28097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28098 
 
28099 
  def __eq__(self, other):
28100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28101 
 
28102 
  def __ne__(self, other):
28103 
    return not (self == other)
10924 vikram.rag 28104 
 
11015 kshitij.so 28105 
class getAllFbbListedItems_args:
10924 vikram.rag 28106 
 
28107 
  thrift_spec = (
28108 
  )
28109 
 
28110 
  def read(self, iprot):
28111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28113 
      return
28114 
    iprot.readStructBegin()
28115 
    while True:
28116 
      (fname, ftype, fid) = iprot.readFieldBegin()
28117 
      if ftype == TType.STOP:
28118 
        break
28119 
      else:
28120 
        iprot.skip(ftype)
28121 
      iprot.readFieldEnd()
28122 
    iprot.readStructEnd()
28123 
 
28124 
  def write(self, oprot):
28125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28127 
      return
11015 kshitij.so 28128 
    oprot.writeStructBegin('getAllFbbListedItems_args')
10924 vikram.rag 28129 
    oprot.writeFieldStop()
28130 
    oprot.writeStructEnd()
28131 
 
28132 
  def validate(self):
28133 
    return
28134 
 
28135 
 
28136 
  def __repr__(self):
28137 
    L = ['%s=%r' % (key, value)
28138 
      for key, value in self.__dict__.iteritems()]
28139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28140 
 
28141 
  def __eq__(self, other):
28142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28143 
 
28144 
  def __ne__(self, other):
28145 
    return not (self == other)
28146 
 
11015 kshitij.so 28147 
class getAllFbbListedItems_result:
10924 vikram.rag 28148 
  """
28149 
  Attributes:
28150 
   - success
28151 
  """
28152 
 
28153 
  thrift_spec = (
28154 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
28155 
  )
28156 
 
28157 
  def __init__(self, success=None,):
28158 
    self.success = success
28159 
 
28160 
  def read(self, iprot):
28161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28163 
      return
28164 
    iprot.readStructBegin()
28165 
    while True:
28166 
      (fname, ftype, fid) = iprot.readFieldBegin()
28167 
      if ftype == TType.STOP:
28168 
        break
28169 
      if fid == 0:
28170 
        if ftype == TType.LIST:
28171 
          self.success = []
28172 
          (_etype630, _size627) = iprot.readListBegin()
28173 
          for _i631 in xrange(_size627):
28174 
            _elem632 = Amazonlisted()
28175 
            _elem632.read(iprot)
28176 
            self.success.append(_elem632)
28177 
          iprot.readListEnd()
28178 
        else:
28179 
          iprot.skip(ftype)
28180 
      else:
28181 
        iprot.skip(ftype)
28182 
      iprot.readFieldEnd()
28183 
    iprot.readStructEnd()
28184 
 
28185 
  def write(self, oprot):
28186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28188 
      return
11015 kshitij.so 28189 
    oprot.writeStructBegin('getAllFbbListedItems_result')
10924 vikram.rag 28190 
    if self.success is not None:
28191 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28192 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28193 
      for iter633 in self.success:
28194 
        iter633.write(oprot)
28195 
      oprot.writeListEnd()
28196 
      oprot.writeFieldEnd()
28197 
    oprot.writeFieldStop()
28198 
    oprot.writeStructEnd()
28199 
 
28200 
  def validate(self):
28201 
    return
28202 
 
28203 
 
28204 
  def __repr__(self):
28205 
    L = ['%s=%r' % (key, value)
28206 
      for key, value in self.__dict__.iteritems()]
28207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28208 
 
28209 
  def __eq__(self, other):
28210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28211 
 
28212 
  def __ne__(self, other):
28213 
    return not (self == other)
11015 kshitij.so 28214 
 
28215 
class getAllFbbPricingItems_args:
28216 
 
28217 
  thrift_spec = (
28218 
  )
28219 
 
28220 
  def read(self, iprot):
28221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28223 
      return
28224 
    iprot.readStructBegin()
28225 
    while True:
28226 
      (fname, ftype, fid) = iprot.readFieldBegin()
28227 
      if ftype == TType.STOP:
28228 
        break
28229 
      else:
28230 
        iprot.skip(ftype)
28231 
      iprot.readFieldEnd()
28232 
    iprot.readStructEnd()
28233 
 
28234 
  def write(self, oprot):
28235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28237 
      return
28238 
    oprot.writeStructBegin('getAllFbbPricingItems_args')
28239 
    oprot.writeFieldStop()
28240 
    oprot.writeStructEnd()
28241 
 
28242 
  def validate(self):
28243 
    return
28244 
 
28245 
 
28246 
  def __repr__(self):
28247 
    L = ['%s=%r' % (key, value)
28248 
      for key, value in self.__dict__.iteritems()]
28249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28250 
 
28251 
  def __eq__(self, other):
28252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28253 
 
28254 
  def __ne__(self, other):
28255 
    return not (self == other)
28256 
 
28257 
class getAllFbbPricingItems_result:
28258 
  """
28259 
  Attributes:
28260 
   - success
28261 
  """
28262 
 
28263 
  thrift_spec = (
28264 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
28265 
  )
28266 
 
28267 
  def __init__(self, success=None,):
28268 
    self.success = success
28269 
 
28270 
  def read(self, iprot):
28271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28273 
      return
28274 
    iprot.readStructBegin()
28275 
    while True:
28276 
      (fname, ftype, fid) = iprot.readFieldBegin()
28277 
      if ftype == TType.STOP:
28278 
        break
28279 
      if fid == 0:
28280 
        if ftype == TType.LIST:
28281 
          self.success = []
28282 
          (_etype637, _size634) = iprot.readListBegin()
28283 
          for _i638 in xrange(_size634):
28284 
            _elem639 = Amazonlisted()
28285 
            _elem639.read(iprot)
28286 
            self.success.append(_elem639)
28287 
          iprot.readListEnd()
28288 
        else:
28289 
          iprot.skip(ftype)
28290 
      else:
28291 
        iprot.skip(ftype)
28292 
      iprot.readFieldEnd()
28293 
    iprot.readStructEnd()
28294 
 
28295 
  def write(self, oprot):
28296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28298 
      return
28299 
    oprot.writeStructBegin('getAllFbbPricingItems_result')
28300 
    if self.success is not None:
28301 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28302 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28303 
      for iter640 in self.success:
28304 
        iter640.write(oprot)
28305 
      oprot.writeListEnd()
28306 
      oprot.writeFieldEnd()
28307 
    oprot.writeFieldStop()
28308 
    oprot.writeStructEnd()
28309 
 
28310 
  def validate(self):
28311 
    return
28312 
 
28313 
 
28314 
  def __repr__(self):
28315 
    L = ['%s=%r' % (key, value)
28316 
      for key, value in self.__dict__.iteritems()]
28317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28318 
 
28319 
  def __eq__(self, other):
28320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28321 
 
28322 
  def __ne__(self, other):
28323 
    return not (self == other)
28324 
 
28325 
class getCountForMarketplaceHistory_args:
28326 
  """
28327 
  Attributes:
28328 
   - source
28329 
   - itemId
28330 
  """
28331 
 
28332 
  thrift_spec = (
28333 
    None, # 0
28334 
    (1, TType.I64, 'source', None, None, ), # 1
28335 
    (2, TType.I64, 'itemId', None, None, ), # 2
28336 
  )
28337 
 
28338 
  def __init__(self, source=None, itemId=None,):
28339 
    self.source = source
28340 
    self.itemId = itemId
28341 
 
28342 
  def read(self, iprot):
28343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28345 
      return
28346 
    iprot.readStructBegin()
28347 
    while True:
28348 
      (fname, ftype, fid) = iprot.readFieldBegin()
28349 
      if ftype == TType.STOP:
28350 
        break
28351 
      if fid == 1:
28352 
        if ftype == TType.I64:
28353 
          self.source = iprot.readI64();
28354 
        else:
28355 
          iprot.skip(ftype)
28356 
      elif fid == 2:
28357 
        if ftype == TType.I64:
28358 
          self.itemId = iprot.readI64();
28359 
        else:
28360 
          iprot.skip(ftype)
28361 
      else:
28362 
        iprot.skip(ftype)
28363 
      iprot.readFieldEnd()
28364 
    iprot.readStructEnd()
28365 
 
28366 
  def write(self, oprot):
28367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28369 
      return
28370 
    oprot.writeStructBegin('getCountForMarketplaceHistory_args')
28371 
    if self.source is not None:
28372 
      oprot.writeFieldBegin('source', TType.I64, 1)
28373 
      oprot.writeI64(self.source)
28374 
      oprot.writeFieldEnd()
28375 
    if self.itemId is not None:
28376 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
28377 
      oprot.writeI64(self.itemId)
28378 
      oprot.writeFieldEnd()
28379 
    oprot.writeFieldStop()
28380 
    oprot.writeStructEnd()
28381 
 
28382 
  def validate(self):
28383 
    return
28384 
 
28385 
 
28386 
  def __repr__(self):
28387 
    L = ['%s=%r' % (key, value)
28388 
      for key, value in self.__dict__.iteritems()]
28389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28390 
 
28391 
  def __eq__(self, other):
28392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28393 
 
28394 
  def __ne__(self, other):
28395 
    return not (self == other)
28396 
 
28397 
class getCountForMarketplaceHistory_result:
28398 
  """
28399 
  Attributes:
28400 
   - success
28401 
  """
28402 
 
28403 
  thrift_spec = (
28404 
    (0, TType.I64, 'success', None, None, ), # 0
28405 
  )
28406 
 
28407 
  def __init__(self, success=None,):
28408 
    self.success = success
28409 
 
28410 
  def read(self, iprot):
28411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28413 
      return
28414 
    iprot.readStructBegin()
28415 
    while True:
28416 
      (fname, ftype, fid) = iprot.readFieldBegin()
28417 
      if ftype == TType.STOP:
28418 
        break
28419 
      if fid == 0:
28420 
        if ftype == TType.I64:
28421 
          self.success = iprot.readI64();
28422 
        else:
28423 
          iprot.skip(ftype)
28424 
      else:
28425 
        iprot.skip(ftype)
28426 
      iprot.readFieldEnd()
28427 
    iprot.readStructEnd()
28428 
 
28429 
  def write(self, oprot):
28430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28432 
      return
28433 
    oprot.writeStructBegin('getCountForMarketplaceHistory_result')
28434 
    if self.success is not None:
28435 
      oprot.writeFieldBegin('success', TType.I64, 0)
28436 
      oprot.writeI64(self.success)
28437 
      oprot.writeFieldEnd()
28438 
    oprot.writeFieldStop()
28439 
    oprot.writeStructEnd()
28440 
 
28441 
  def validate(self):
28442 
    return
28443 
 
28444 
 
28445 
  def __repr__(self):
28446 
    L = ['%s=%r' % (key, value)
28447 
      for key, value in self.__dict__.iteritems()]
28448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28449 
 
28450 
  def __eq__(self, other):
28451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28452 
 
28453 
  def __ne__(self, other):
28454 
    return not (self == other)
28455 
 
28456 
class getMarketplaceHistoryByDate_args:
28457 
  """
28458 
  Attributes:
28459 
   - source
28460 
   - startDate
28461 
   - endDate
28462 
   - offset
28463 
   - limit
28464 
   - itemId
28465 
  """
28466 
 
28467 
  thrift_spec = (
28468 
    None, # 0
28469 
    (1, TType.I64, 'source', None, None, ), # 1
28470 
    (2, TType.I64, 'startDate', None, None, ), # 2
28471 
    (3, TType.I64, 'endDate', None, None, ), # 3
28472 
    (4, TType.I64, 'offset', None, None, ), # 4
28473 
    (5, TType.I64, 'limit', None, None, ), # 5
28474 
    (6, TType.I64, 'itemId', None, None, ), # 6
28475 
  )
28476 
 
28477 
  def __init__(self, source=None, startDate=None, endDate=None, offset=None, limit=None, itemId=None,):
28478 
    self.source = source
28479 
    self.startDate = startDate
28480 
    self.endDate = endDate
28481 
    self.offset = offset
28482 
    self.limit = limit
28483 
    self.itemId = itemId
28484 
 
28485 
  def read(self, iprot):
28486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28488 
      return
28489 
    iprot.readStructBegin()
28490 
    while True:
28491 
      (fname, ftype, fid) = iprot.readFieldBegin()
28492 
      if ftype == TType.STOP:
28493 
        break
28494 
      if fid == 1:
28495 
        if ftype == TType.I64:
28496 
          self.source = iprot.readI64();
28497 
        else:
28498 
          iprot.skip(ftype)
28499 
      elif fid == 2:
28500 
        if ftype == TType.I64:
28501 
          self.startDate = iprot.readI64();
28502 
        else:
28503 
          iprot.skip(ftype)
28504 
      elif fid == 3:
28505 
        if ftype == TType.I64:
28506 
          self.endDate = iprot.readI64();
28507 
        else:
28508 
          iprot.skip(ftype)
28509 
      elif fid == 4:
28510 
        if ftype == TType.I64:
28511 
          self.offset = iprot.readI64();
28512 
        else:
28513 
          iprot.skip(ftype)
28514 
      elif fid == 5:
28515 
        if ftype == TType.I64:
28516 
          self.limit = iprot.readI64();
28517 
        else:
28518 
          iprot.skip(ftype)
28519 
      elif fid == 6:
28520 
        if ftype == TType.I64:
28521 
          self.itemId = iprot.readI64();
28522 
        else:
28523 
          iprot.skip(ftype)
28524 
      else:
28525 
        iprot.skip(ftype)
28526 
      iprot.readFieldEnd()
28527 
    iprot.readStructEnd()
28528 
 
28529 
  def write(self, oprot):
28530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28532 
      return
28533 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_args')
28534 
    if self.source is not None:
28535 
      oprot.writeFieldBegin('source', TType.I64, 1)
28536 
      oprot.writeI64(self.source)
28537 
      oprot.writeFieldEnd()
28538 
    if self.startDate is not None:
28539 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
28540 
      oprot.writeI64(self.startDate)
28541 
      oprot.writeFieldEnd()
28542 
    if self.endDate is not None:
28543 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
28544 
      oprot.writeI64(self.endDate)
28545 
      oprot.writeFieldEnd()
28546 
    if self.offset is not None:
28547 
      oprot.writeFieldBegin('offset', TType.I64, 4)
28548 
      oprot.writeI64(self.offset)
28549 
      oprot.writeFieldEnd()
28550 
    if self.limit is not None:
28551 
      oprot.writeFieldBegin('limit', TType.I64, 5)
28552 
      oprot.writeI64(self.limit)
28553 
      oprot.writeFieldEnd()
28554 
    if self.itemId is not None:
28555 
      oprot.writeFieldBegin('itemId', TType.I64, 6)
28556 
      oprot.writeI64(self.itemId)
28557 
      oprot.writeFieldEnd()
28558 
    oprot.writeFieldStop()
28559 
    oprot.writeStructEnd()
28560 
 
28561 
  def validate(self):
28562 
    return
28563 
 
28564 
 
28565 
  def __repr__(self):
28566 
    L = ['%s=%r' % (key, value)
28567 
      for key, value in self.__dict__.iteritems()]
28568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28569 
 
28570 
  def __eq__(self, other):
28571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28572 
 
28573 
  def __ne__(self, other):
28574 
    return not (self == other)
28575 
 
28576 
class getMarketplaceHistoryByDate_result:
28577 
  """
28578 
  Attributes:
28579 
   - success
28580 
  """
28581 
 
28582 
  thrift_spec = (
28583 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
28584 
  )
28585 
 
28586 
  def __init__(self, success=None,):
28587 
    self.success = success
28588 
 
28589 
  def read(self, iprot):
28590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28592 
      return
28593 
    iprot.readStructBegin()
28594 
    while True:
28595 
      (fname, ftype, fid) = iprot.readFieldBegin()
28596 
      if ftype == TType.STOP:
28597 
        break
28598 
      if fid == 0:
28599 
        if ftype == TType.LIST:
28600 
          self.success = []
28601 
          (_etype644, _size641) = iprot.readListBegin()
28602 
          for _i645 in xrange(_size641):
28603 
            _elem646 = MarketplaceHistory()
28604 
            _elem646.read(iprot)
28605 
            self.success.append(_elem646)
28606 
          iprot.readListEnd()
28607 
        else:
28608 
          iprot.skip(ftype)
28609 
      else:
28610 
        iprot.skip(ftype)
28611 
      iprot.readFieldEnd()
28612 
    iprot.readStructEnd()
28613 
 
28614 
  def write(self, oprot):
28615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28617 
      return
28618 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_result')
28619 
    if self.success is not None:
28620 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28621 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28622 
      for iter647 in self.success:
28623 
        iter647.write(oprot)
28624 
      oprot.writeListEnd()
28625 
      oprot.writeFieldEnd()
28626 
    oprot.writeFieldStop()
28627 
    oprot.writeStructEnd()
28628 
 
28629 
  def validate(self):
28630 
    return
28631 
 
28632 
 
28633 
  def __repr__(self):
28634 
    L = ['%s=%r' % (key, value)
28635 
      for key, value in self.__dict__.iteritems()]
28636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28637 
 
28638 
  def __eq__(self, other):
28639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28640 
 
28641 
  def __ne__(self, other):
28642 
    return not (self == other)
11531 vikram.rag 28643 
 
28644 
class getPrivateDealDetails_args:
28645 
  """
28646 
  Attributes:
28647 
   - item_id
28648 
  """
28649 
 
28650 
  thrift_spec = (
28651 
    None, # 0
28652 
    (1, TType.I64, 'item_id', None, None, ), # 1
28653 
  )
28654 
 
28655 
  def __init__(self, item_id=None,):
28656 
    self.item_id = item_id
28657 
 
28658 
  def read(self, iprot):
28659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28661 
      return
28662 
    iprot.readStructBegin()
28663 
    while True:
28664 
      (fname, ftype, fid) = iprot.readFieldBegin()
28665 
      if ftype == TType.STOP:
28666 
        break
28667 
      if fid == 1:
28668 
        if ftype == TType.I64:
28669 
          self.item_id = iprot.readI64();
28670 
        else:
28671 
          iprot.skip(ftype)
28672 
      else:
28673 
        iprot.skip(ftype)
28674 
      iprot.readFieldEnd()
28675 
    iprot.readStructEnd()
28676 
 
28677 
  def write(self, oprot):
28678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28680 
      return
28681 
    oprot.writeStructBegin('getPrivateDealDetails_args')
28682 
    if self.item_id is not None:
28683 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
28684 
      oprot.writeI64(self.item_id)
28685 
      oprot.writeFieldEnd()
28686 
    oprot.writeFieldStop()
28687 
    oprot.writeStructEnd()
28688 
 
28689 
  def validate(self):
28690 
    return
28691 
 
28692 
 
28693 
  def __repr__(self):
28694 
    L = ['%s=%r' % (key, value)
28695 
      for key, value in self.__dict__.iteritems()]
28696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28697 
 
28698 
  def __eq__(self, other):
28699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28700 
 
28701 
  def __ne__(self, other):
28702 
    return not (self == other)
28703 
 
28704 
class getPrivateDealDetails_result:
28705 
  """
28706 
  Attributes:
28707 
   - success
28708 
  """
28709 
 
28710 
  thrift_spec = (
28711 
    (0, TType.STRUCT, 'success', (PrivateDeal, PrivateDeal.thrift_spec), None, ), # 0
28712 
  )
28713 
 
28714 
  def __init__(self, success=None,):
28715 
    self.success = success
28716 
 
28717 
  def read(self, iprot):
28718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28720 
      return
28721 
    iprot.readStructBegin()
28722 
    while True:
28723 
      (fname, ftype, fid) = iprot.readFieldBegin()
28724 
      if ftype == TType.STOP:
28725 
        break
28726 
      if fid == 0:
28727 
        if ftype == TType.STRUCT:
28728 
          self.success = PrivateDeal()
28729 
          self.success.read(iprot)
28730 
        else:
28731 
          iprot.skip(ftype)
28732 
      else:
28733 
        iprot.skip(ftype)
28734 
      iprot.readFieldEnd()
28735 
    iprot.readStructEnd()
28736 
 
28737 
  def write(self, oprot):
28738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28740 
      return
28741 
    oprot.writeStructBegin('getPrivateDealDetails_result')
28742 
    if self.success is not None:
28743 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28744 
      self.success.write(oprot)
28745 
      oprot.writeFieldEnd()
28746 
    oprot.writeFieldStop()
28747 
    oprot.writeStructEnd()
28748 
 
28749 
  def validate(self):
28750 
    return
28751 
 
28752 
 
28753 
  def __repr__(self):
28754 
    L = ['%s=%r' % (key, value)
28755 
      for key, value in self.__dict__.iteritems()]
28756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28757 
 
28758 
  def __eq__(self, other):
28759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28760 
 
28761 
  def __ne__(self, other):
28762 
    return not (self == other)
28763 
 
28764 
class getPrivateDealItems_args:
28765 
  """
28766 
  Attributes:
28767 
   - offset
28768 
   - limit
28769 
  """
28770 
 
28771 
  thrift_spec = (
28772 
    None, # 0
28773 
    (1, TType.I64, 'offset', None, None, ), # 1
28774 
    (2, TType.I64, 'limit', None, None, ), # 2
28775 
  )
28776 
 
28777 
  def __init__(self, offset=None, limit=None,):
28778 
    self.offset = offset
28779 
    self.limit = limit
28780 
 
28781 
  def read(self, iprot):
28782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28784 
      return
28785 
    iprot.readStructBegin()
28786 
    while True:
28787 
      (fname, ftype, fid) = iprot.readFieldBegin()
28788 
      if ftype == TType.STOP:
28789 
        break
28790 
      if fid == 1:
28791 
        if ftype == TType.I64:
28792 
          self.offset = iprot.readI64();
28793 
        else:
28794 
          iprot.skip(ftype)
28795 
      elif fid == 2:
28796 
        if ftype == TType.I64:
28797 
          self.limit = iprot.readI64();
28798 
        else:
28799 
          iprot.skip(ftype)
28800 
      else:
28801 
        iprot.skip(ftype)
28802 
      iprot.readFieldEnd()
28803 
    iprot.readStructEnd()
28804 
 
28805 
  def write(self, oprot):
28806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28808 
      return
28809 
    oprot.writeStructBegin('getPrivateDealItems_args')
28810 
    if self.offset is not None:
28811 
      oprot.writeFieldBegin('offset', TType.I64, 1)
28812 
      oprot.writeI64(self.offset)
28813 
      oprot.writeFieldEnd()
28814 
    if self.limit is not None:
28815 
      oprot.writeFieldBegin('limit', TType.I64, 2)
28816 
      oprot.writeI64(self.limit)
28817 
      oprot.writeFieldEnd()
28818 
    oprot.writeFieldStop()
28819 
    oprot.writeStructEnd()
28820 
 
28821 
  def validate(self):
28822 
    return
28823 
 
28824 
 
28825 
  def __repr__(self):
28826 
    L = ['%s=%r' % (key, value)
28827 
      for key, value in self.__dict__.iteritems()]
28828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28829 
 
28830 
  def __eq__(self, other):
28831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28832 
 
28833 
  def __ne__(self, other):
28834 
    return not (self == other)
28835 
 
28836 
class getPrivateDealItems_result:
28837 
  """
28838 
  Attributes:
28839 
   - success
28840 
  """
28841 
 
28842 
  thrift_spec = (
28843 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
28844 
  )
28845 
 
28846 
  def __init__(self, success=None,):
28847 
    self.success = success
28848 
 
28849 
  def read(self, iprot):
28850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28852 
      return
28853 
    iprot.readStructBegin()
28854 
    while True:
28855 
      (fname, ftype, fid) = iprot.readFieldBegin()
28856 
      if ftype == TType.STOP:
28857 
        break
28858 
      if fid == 0:
28859 
        if ftype == TType.LIST:
28860 
          self.success = []
28861 
          (_etype651, _size648) = iprot.readListBegin()
28862 
          for _i652 in xrange(_size648):
28863 
            _elem653 = Item()
28864 
            _elem653.read(iprot)
28865 
            self.success.append(_elem653)
28866 
          iprot.readListEnd()
28867 
        else:
28868 
          iprot.skip(ftype)
28869 
      else:
28870 
        iprot.skip(ftype)
28871 
      iprot.readFieldEnd()
28872 
    iprot.readStructEnd()
28873 
 
28874 
  def write(self, oprot):
28875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28877 
      return
28878 
    oprot.writeStructBegin('getPrivateDealItems_result')
28879 
    if self.success is not None:
28880 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28881 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28882 
      for iter654 in self.success:
28883 
        iter654.write(oprot)
28884 
      oprot.writeListEnd()
28885 
      oprot.writeFieldEnd()
28886 
    oprot.writeFieldStop()
28887 
    oprot.writeStructEnd()
28888 
 
28889 
  def validate(self):
28890 
    return
28891 
 
28892 
 
28893 
  def __repr__(self):
28894 
    L = ['%s=%r' % (key, value)
28895 
      for key, value in self.__dict__.iteritems()]
28896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28897 
 
28898 
  def __eq__(self, other):
28899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28900 
 
28901 
  def __ne__(self, other):
28902 
    return not (self == other)
28903 
 
11592 amit.gupta 28904 
class getAllActivePrivateDeals_args:
11653 amit.gupta 28905 
  """
28906 
  Attributes:
28907 
   - itemIds
28908 
   - daysDelta
28909 
  """
11592 amit.gupta 28910 
 
28911 
  thrift_spec = (
11653 amit.gupta 28912 
    None, # 0
28913 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
28914 
    (2, TType.I64, 'daysDelta', None, None, ), # 2
11592 amit.gupta 28915 
  )
28916 
 
11653 amit.gupta 28917 
  def __init__(self, itemIds=None, daysDelta=None,):
28918 
    self.itemIds = itemIds
28919 
    self.daysDelta = daysDelta
28920 
 
11592 amit.gupta 28921 
  def read(self, iprot):
28922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28924 
      return
28925 
    iprot.readStructBegin()
28926 
    while True:
28927 
      (fname, ftype, fid) = iprot.readFieldBegin()
28928 
      if ftype == TType.STOP:
28929 
        break
11653 amit.gupta 28930 
      if fid == 1:
28931 
        if ftype == TType.LIST:
28932 
          self.itemIds = []
28933 
          (_etype658, _size655) = iprot.readListBegin()
28934 
          for _i659 in xrange(_size655):
28935 
            _elem660 = iprot.readI64();
28936 
            self.itemIds.append(_elem660)
28937 
          iprot.readListEnd()
28938 
        else:
28939 
          iprot.skip(ftype)
28940 
      elif fid == 2:
28941 
        if ftype == TType.I64:
28942 
          self.daysDelta = iprot.readI64();
28943 
        else:
28944 
          iprot.skip(ftype)
11592 amit.gupta 28945 
      else:
28946 
        iprot.skip(ftype)
28947 
      iprot.readFieldEnd()
28948 
    iprot.readStructEnd()
28949 
 
28950 
  def write(self, oprot):
28951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28953 
      return
28954 
    oprot.writeStructBegin('getAllActivePrivateDeals_args')
11653 amit.gupta 28955 
    if self.itemIds is not None:
28956 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
28957 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
28958 
      for iter661 in self.itemIds:
28959 
        oprot.writeI64(iter661)
28960 
      oprot.writeListEnd()
28961 
      oprot.writeFieldEnd()
28962 
    if self.daysDelta is not None:
28963 
      oprot.writeFieldBegin('daysDelta', TType.I64, 2)
28964 
      oprot.writeI64(self.daysDelta)
28965 
      oprot.writeFieldEnd()
11592 amit.gupta 28966 
    oprot.writeFieldStop()
28967 
    oprot.writeStructEnd()
28968 
 
28969 
  def validate(self):
28970 
    return
28971 
 
28972 
 
28973 
  def __repr__(self):
28974 
    L = ['%s=%r' % (key, value)
28975 
      for key, value in self.__dict__.iteritems()]
28976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28977 
 
28978 
  def __eq__(self, other):
28979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28980 
 
28981 
  def __ne__(self, other):
28982 
    return not (self == other)
28983 
 
28984 
class getAllActivePrivateDeals_result:
28985 
  """
28986 
  Attributes:
28987 
   - success
28988 
  """
28989 
 
28990 
  thrift_spec = (
28991 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(PrivateDeal, PrivateDeal.thrift_spec)), None, ), # 0
28992 
  )
28993 
 
28994 
  def __init__(self, success=None,):
28995 
    self.success = success
28996 
 
28997 
  def read(self, iprot):
28998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29000 
      return
29001 
    iprot.readStructBegin()
29002 
    while True:
29003 
      (fname, ftype, fid) = iprot.readFieldBegin()
29004 
      if ftype == TType.STOP:
29005 
        break
29006 
      if fid == 0:
29007 
        if ftype == TType.MAP:
29008 
          self.success = {}
11653 amit.gupta 29009 
          (_ktype663, _vtype664, _size662 ) = iprot.readMapBegin()
29010 
          for _i666 in xrange(_size662):
29011 
            _key667 = iprot.readI64();
29012 
            _val668 = PrivateDeal()
29013 
            _val668.read(iprot)
29014 
            self.success[_key667] = _val668
11592 amit.gupta 29015 
          iprot.readMapEnd()
29016 
        else:
29017 
          iprot.skip(ftype)
29018 
      else:
29019 
        iprot.skip(ftype)
29020 
      iprot.readFieldEnd()
29021 
    iprot.readStructEnd()
29022 
 
29023 
  def write(self, oprot):
29024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29026 
      return
29027 
    oprot.writeStructBegin('getAllActivePrivateDeals_result')
29028 
    if self.success is not None:
29029 
      oprot.writeFieldBegin('success', TType.MAP, 0)
29030 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
11653 amit.gupta 29031 
      for kiter669,viter670 in self.success.items():
29032 
        oprot.writeI64(kiter669)
29033 
        viter670.write(oprot)
11592 amit.gupta 29034 
      oprot.writeMapEnd()
29035 
      oprot.writeFieldEnd()
29036 
    oprot.writeFieldStop()
29037 
    oprot.writeStructEnd()
29038 
 
29039 
  def validate(self):
29040 
    return
29041 
 
29042 
 
29043 
  def __repr__(self):
29044 
    L = ['%s=%r' % (key, value)
29045 
      for key, value in self.__dict__.iteritems()]
29046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29047 
 
29048 
  def __eq__(self, other):
29049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29050 
 
29051 
  def __ne__(self, other):
29052 
    return not (self == other)
29053 
 
11531 vikram.rag 29054 
class addOrUpdatePrivateDeal_args:
29055 
  """
29056 
  Attributes:
29057 
   - privateDeal
29058 
  """
29059 
 
29060 
  thrift_spec = (
29061 
    None, # 0
29062 
    (1, TType.STRUCT, 'privateDeal', (PrivateDeal, PrivateDeal.thrift_spec), None, ), # 1
29063 
  )
29064 
 
29065 
  def __init__(self, privateDeal=None,):
29066 
    self.privateDeal = privateDeal
29067 
 
29068 
  def read(self, iprot):
29069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29071 
      return
29072 
    iprot.readStructBegin()
29073 
    while True:
29074 
      (fname, ftype, fid) = iprot.readFieldBegin()
29075 
      if ftype == TType.STOP:
29076 
        break
29077 
      if fid == 1:
29078 
        if ftype == TType.STRUCT:
29079 
          self.privateDeal = PrivateDeal()
29080 
          self.privateDeal.read(iprot)
29081 
        else:
29082 
          iprot.skip(ftype)
29083 
      else:
29084 
        iprot.skip(ftype)
29085 
      iprot.readFieldEnd()
29086 
    iprot.readStructEnd()
29087 
 
29088 
  def write(self, oprot):
29089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29091 
      return
29092 
    oprot.writeStructBegin('addOrUpdatePrivateDeal_args')
29093 
    if self.privateDeal is not None:
29094 
      oprot.writeFieldBegin('privateDeal', TType.STRUCT, 1)
29095 
      self.privateDeal.write(oprot)
29096 
      oprot.writeFieldEnd()
29097 
    oprot.writeFieldStop()
29098 
    oprot.writeStructEnd()
29099 
 
29100 
  def validate(self):
29101 
    return
29102 
 
29103 
 
29104 
  def __repr__(self):
29105 
    L = ['%s=%r' % (key, value)
29106 
      for key, value in self.__dict__.iteritems()]
29107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29108 
 
29109 
  def __eq__(self, other):
29110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29111 
 
29112 
  def __ne__(self, other):
29113 
    return not (self == other)
29114 
 
29115 
class addOrUpdatePrivateDeal_result:
29116 
  """
29117 
  Attributes:
29118 
   - success
29119 
  """
29120 
 
29121 
  thrift_spec = (
29122 
    (0, TType.BOOL, 'success', None, None, ), # 0
29123 
  )
29124 
 
29125 
  def __init__(self, success=None,):
29126 
    self.success = success
29127 
 
29128 
  def read(self, iprot):
29129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29131 
      return
29132 
    iprot.readStructBegin()
29133 
    while True:
29134 
      (fname, ftype, fid) = iprot.readFieldBegin()
29135 
      if ftype == TType.STOP:
29136 
        break
29137 
      if fid == 0:
29138 
        if ftype == TType.BOOL:
29139 
          self.success = iprot.readBool();
29140 
        else:
29141 
          iprot.skip(ftype)
29142 
      else:
29143 
        iprot.skip(ftype)
29144 
      iprot.readFieldEnd()
29145 
    iprot.readStructEnd()
29146 
 
29147 
  def write(self, oprot):
29148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29150 
      return
29151 
    oprot.writeStructBegin('addOrUpdatePrivateDeal_result')
29152 
    if self.success is not None:
29153 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29154 
      oprot.writeBool(self.success)
29155 
      oprot.writeFieldEnd()
29156 
    oprot.writeFieldStop()
29157 
    oprot.writeStructEnd()
29158 
 
29159 
  def validate(self):
29160 
    return
29161 
 
29162 
 
29163 
  def __repr__(self):
29164 
    L = ['%s=%r' % (key, value)
29165 
      for key, value in self.__dict__.iteritems()]
29166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29167 
 
29168 
  def __eq__(self, other):
29169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29170 
 
29171 
  def __ne__(self, other):
29172 
    return not (self == other)
11635 vikram.rag 29173 
 
29174 
class getPrivateDealsCatalogIds_args:
29175 
  """
29176 
  Attributes:
29177 
   - beginIndex
29178 
   - totalItems
29179 
  """
29180 
 
29181 
  thrift_spec = (
29182 
    None, # 0
29183 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
29184 
    (2, TType.I64, 'totalItems', None, None, ), # 2
29185 
  )
29186 
 
29187 
  def __init__(self, beginIndex=None, totalItems=None,):
29188 
    self.beginIndex = beginIndex
29189 
    self.totalItems = totalItems
29190 
 
29191 
  def read(self, iprot):
29192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29194 
      return
29195 
    iprot.readStructBegin()
29196 
    while True:
29197 
      (fname, ftype, fid) = iprot.readFieldBegin()
29198 
      if ftype == TType.STOP:
29199 
        break
29200 
      if fid == 1:
29201 
        if ftype == TType.I64:
29202 
          self.beginIndex = iprot.readI64();
29203 
        else:
29204 
          iprot.skip(ftype)
29205 
      elif fid == 2:
29206 
        if ftype == TType.I64:
29207 
          self.totalItems = iprot.readI64();
29208 
        else:
29209 
          iprot.skip(ftype)
29210 
      else:
29211 
        iprot.skip(ftype)
29212 
      iprot.readFieldEnd()
29213 
    iprot.readStructEnd()
29214 
 
29215 
  def write(self, oprot):
29216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29218 
      return
29219 
    oprot.writeStructBegin('getPrivateDealsCatalogIds_args')
29220 
    if self.beginIndex is not None:
29221 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
29222 
      oprot.writeI64(self.beginIndex)
29223 
      oprot.writeFieldEnd()
29224 
    if self.totalItems is not None:
29225 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
29226 
      oprot.writeI64(self.totalItems)
29227 
      oprot.writeFieldEnd()
29228 
    oprot.writeFieldStop()
29229 
    oprot.writeStructEnd()
29230 
 
29231 
  def validate(self):
29232 
    return
29233 
 
29234 
 
29235 
  def __repr__(self):
29236 
    L = ['%s=%r' % (key, value)
29237 
      for key, value in self.__dict__.iteritems()]
29238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29239 
 
29240 
  def __eq__(self, other):
29241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29242 
 
29243 
  def __ne__(self, other):
29244 
    return not (self == other)
29245 
 
29246 
class getPrivateDealsCatalogIds_result:
29247 
  """
29248 
  Attributes:
29249 
   - success
29250 
   - cex
29251 
  """
29252 
 
29253 
  thrift_spec = (
29254 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
29255 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
29256 
  )
29257 
 
29258 
  def __init__(self, success=None, cex=None,):
29259 
    self.success = success
29260 
    self.cex = cex
29261 
 
29262 
  def read(self, iprot):
29263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29265 
      return
29266 
    iprot.readStructBegin()
29267 
    while True:
29268 
      (fname, ftype, fid) = iprot.readFieldBegin()
29269 
      if ftype == TType.STOP:
29270 
        break
29271 
      if fid == 0:
29272 
        if ftype == TType.LIST:
29273 
          self.success = []
11653 amit.gupta 29274 
          (_etype674, _size671) = iprot.readListBegin()
29275 
          for _i675 in xrange(_size671):
29276 
            _elem676 = iprot.readI64();
29277 
            self.success.append(_elem676)
11635 vikram.rag 29278 
          iprot.readListEnd()
29279 
        else:
29280 
          iprot.skip(ftype)
29281 
      elif fid == 1:
29282 
        if ftype == TType.STRUCT:
29283 
          self.cex = CatalogServiceException()
29284 
          self.cex.read(iprot)
29285 
        else:
29286 
          iprot.skip(ftype)
29287 
      else:
29288 
        iprot.skip(ftype)
29289 
      iprot.readFieldEnd()
29290 
    iprot.readStructEnd()
29291 
 
29292 
  def write(self, oprot):
29293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29295 
      return
29296 
    oprot.writeStructBegin('getPrivateDealsCatalogIds_result')
29297 
    if self.success is not None:
29298 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29299 
      oprot.writeListBegin(TType.I64, len(self.success))
11653 amit.gupta 29300 
      for iter677 in self.success:
29301 
        oprot.writeI64(iter677)
11635 vikram.rag 29302 
      oprot.writeListEnd()
29303 
      oprot.writeFieldEnd()
29304 
    if self.cex is not None:
29305 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
29306 
      self.cex.write(oprot)
29307 
      oprot.writeFieldEnd()
29308 
    oprot.writeFieldStop()
29309 
    oprot.writeStructEnd()
29310 
 
29311 
  def validate(self):
29312 
    return
29313 
 
29314 
 
29315 
  def __repr__(self):
29316 
    L = ['%s=%r' % (key, value)
29317 
      for key, value in self.__dict__.iteritems()]
29318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29319 
 
29320 
  def __eq__(self, other):
29321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29322 
 
29323 
  def __ne__(self, other):
29324 
    return not (self == other)
11645 amit.gupta 29325 
 
29326 
class getPrivateDealsCount_args:
29327 
 
29328 
  thrift_spec = (
29329 
  )
29330 
 
29331 
  def read(self, iprot):
29332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29334 
      return
29335 
    iprot.readStructBegin()
29336 
    while True:
29337 
      (fname, ftype, fid) = iprot.readFieldBegin()
29338 
      if ftype == TType.STOP:
29339 
        break
29340 
      else:
29341 
        iprot.skip(ftype)
29342 
      iprot.readFieldEnd()
29343 
    iprot.readStructEnd()
29344 
 
29345 
  def write(self, oprot):
29346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29348 
      return
29349 
    oprot.writeStructBegin('getPrivateDealsCount_args')
29350 
    oprot.writeFieldStop()
29351 
    oprot.writeStructEnd()
29352 
 
29353 
  def validate(self):
29354 
    return
29355 
 
29356 
 
29357 
  def __repr__(self):
29358 
    L = ['%s=%r' % (key, value)
29359 
      for key, value in self.__dict__.iteritems()]
29360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29361 
 
29362 
  def __eq__(self, other):
29363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29364 
 
29365 
  def __ne__(self, other):
29366 
    return not (self == other)
29367 
 
29368 
class getPrivateDealsCount_result:
29369 
  """
29370 
  Attributes:
29371 
   - success
29372 
  """
29373 
 
29374 
  thrift_spec = (
29375 
    (0, TType.I32, 'success', None, None, ), # 0
29376 
  )
29377 
 
29378 
  def __init__(self, success=None,):
29379 
    self.success = success
29380 
 
29381 
  def read(self, iprot):
29382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29384 
      return
29385 
    iprot.readStructBegin()
29386 
    while True:
29387 
      (fname, ftype, fid) = iprot.readFieldBegin()
29388 
      if ftype == TType.STOP:
29389 
        break
29390 
      if fid == 0:
29391 
        if ftype == TType.I32:
29392 
          self.success = iprot.readI32();
29393 
        else:
29394 
          iprot.skip(ftype)
29395 
      else:
29396 
        iprot.skip(ftype)
29397 
      iprot.readFieldEnd()
29398 
    iprot.readStructEnd()
29399 
 
29400 
  def write(self, oprot):
29401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29403 
      return
29404 
    oprot.writeStructBegin('getPrivateDealsCount_result')
29405 
    if self.success is not None:
29406 
      oprot.writeFieldBegin('success', TType.I32, 0)
29407 
      oprot.writeI32(self.success)
29408 
      oprot.writeFieldEnd()
29409 
    oprot.writeFieldStop()
29410 
    oprot.writeStructEnd()
29411 
 
29412 
  def validate(self):
29413 
    return
29414 
 
29415 
 
29416 
  def __repr__(self):
29417 
    L = ['%s=%r' % (key, value)
29418 
      for key, value in self.__dict__.iteritems()]
29419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29420 
 
29421 
  def __eq__(self, other):
29422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29423 
 
29424 
  def __ne__(self, other):
29425 
    return not (self == other)