Subversion Repositories SmartDukaan

Rev

Rev 11015 | Rev 11592 | 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 
 
1164 
  def addOrUpdatePrivateDeal(self, privateDeal):
1165 
    """
1166 
    Parameters:
1167 
     - privateDeal
1168 
    """
1169 
    pass
1170 
 
1171 
 
5944 mandeep.dh 1172 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1173 
  def __init__(self, iprot, oprot=None):
1174 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1175 
 
1176 
  def addItem(self, item):
1177 
    """
1178 
    Availability and inventory attributes
1179 
 
1180 
    Parameters:
1181 
     - item
1182 
    """
1183 
    self.send_addItem(item)
1184 
    return self.recv_addItem()
1185 
 
1186 
  def send_addItem(self, item):
1187 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1188 
    args = addItem_args()
1189 
    args.item = item
1190 
    args.write(self._oprot)
1191 
    self._oprot.writeMessageEnd()
1192 
    self._oprot.trans.flush()
1193 
 
1194 
  def recv_addItem(self, ):
1195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1196 
    if mtype == TMessageType.EXCEPTION:
1197 
      x = TApplicationException()
1198 
      x.read(self._iprot)
1199 
      self._iprot.readMessageEnd()
1200 
      raise x
1201 
    result = addItem_result()
1202 
    result.read(self._iprot)
1203 
    self._iprot.readMessageEnd()
1204 
    if result.success is not None:
1205 
      return result.success
1206 
    if result.cex is not None:
1207 
      raise result.cex
1208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1209 
 
1210 
  def updateItem(self, item):
1211 
    """
1212 
    Parameters:
1213 
     - item
1214 
    """
1215 
    self.send_updateItem(item)
1216 
    return self.recv_updateItem()
1217 
 
1218 
  def send_updateItem(self, item):
1219 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1220 
    args = updateItem_args()
1221 
    args.item = item
1222 
    args.write(self._oprot)
1223 
    self._oprot.writeMessageEnd()
1224 
    self._oprot.trans.flush()
1225 
 
1226 
  def recv_updateItem(self, ):
1227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1228 
    if mtype == TMessageType.EXCEPTION:
1229 
      x = TApplicationException()
1230 
      x.read(self._iprot)
1231 
      self._iprot.readMessageEnd()
1232 
      raise x
1233 
    result = updateItem_result()
1234 
    result.read(self._iprot)
1235 
    self._iprot.readMessageEnd()
1236 
    if result.success is not None:
1237 
      return result.success
1238 
    if result.cex is not None:
1239 
      raise result.cex
1240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1241 
 
1242 
  def isActive(self, itemId):
1243 
    """
1244 
    Checks if the item given to the corresponding itemId is active. If it's active,
1245 
    whether it's risky and if it's risky, its inventory position.
1246 
 
1247 
    Parameters:
1248 
     - itemId
1249 
    """
1250 
    self.send_isActive(itemId)
1251 
    return self.recv_isActive()
1252 
 
1253 
  def send_isActive(self, itemId):
1254 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1255 
    args = isActive_args()
1256 
    args.itemId = itemId
1257 
    args.write(self._oprot)
1258 
    self._oprot.writeMessageEnd()
1259 
    self._oprot.trans.flush()
1260 
 
1261 
  def recv_isActive(self, ):
1262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1263 
    if mtype == TMessageType.EXCEPTION:
1264 
      x = TApplicationException()
1265 
      x.read(self._iprot)
1266 
      self._iprot.readMessageEnd()
1267 
      raise x
1268 
    result = isActive_result()
1269 
    result.read(self._iprot)
1270 
    self._iprot.readMessageEnd()
1271 
    if result.success is not None:
1272 
      return result.success
1273 
    if result.isex is not None:
1274 
      raise result.isex
1275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1276 
 
7438 amit.gupta 1277 
  def getItemsStatus(self, itemIds):
1278 
    """
1279 
    Parameters:
1280 
     - itemIds
1281 
    """
1282 
    self.send_getItemsStatus(itemIds)
1283 
    return self.recv_getItemsStatus()
1284 
 
1285 
  def send_getItemsStatus(self, itemIds):
1286 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1287 
    args = getItemsStatus_args()
1288 
    args.itemIds = itemIds
1289 
    args.write(self._oprot)
1290 
    self._oprot.writeMessageEnd()
1291 
    self._oprot.trans.flush()
1292 
 
1293 
  def recv_getItemsStatus(self, ):
1294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1295 
    if mtype == TMessageType.EXCEPTION:
1296 
      x = TApplicationException()
1297 
      x.read(self._iprot)
1298 
      self._iprot.readMessageEnd()
1299 
      raise x
1300 
    result = getItemsStatus_result()
1301 
    result.read(self._iprot)
1302 
    self._iprot.readMessageEnd()
1303 
    if result.success is not None:
1304 
      return result.success
1305 
    if result.isex is not None:
1306 
      raise result.isex
1307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1308 
 
5944 mandeep.dh 1309 
  def getItemStatusDescription(self, itemId):
1310 
    """
1311 
    Parameters:
1312 
     - itemId
1313 
    """
1314 
    self.send_getItemStatusDescription(itemId)
1315 
    return self.recv_getItemStatusDescription()
1316 
 
1317 
  def send_getItemStatusDescription(self, itemId):
1318 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1319 
    args = getItemStatusDescription_args()
1320 
    args.itemId = itemId
1321 
    args.write(self._oprot)
1322 
    self._oprot.writeMessageEnd()
1323 
    self._oprot.trans.flush()
1324 
 
1325 
  def recv_getItemStatusDescription(self, ):
1326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1327 
    if mtype == TMessageType.EXCEPTION:
1328 
      x = TApplicationException()
1329 
      x.read(self._iprot)
1330 
      self._iprot.readMessageEnd()
1331 
      raise x
1332 
    result = getItemStatusDescription_result()
1333 
    result.read(self._iprot)
1334 
    self._iprot.readMessageEnd()
1335 
    if result.success is not None:
1336 
      return result.success
1337 
    if result.isex is not None:
1338 
      raise result.isex
1339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1340 
 
1341 
  def startItemOn(self, item_id, timestamp):
1342 
    """
1343 
    Parameters:
1344 
     - item_id
1345 
     - timestamp
1346 
    """
1347 
    self.send_startItemOn(item_id, timestamp)
1348 
    self.recv_startItemOn()
1349 
 
1350 
  def send_startItemOn(self, item_id, timestamp):
1351 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1352 
    args = startItemOn_args()
1353 
    args.item_id = item_id
1354 
    args.timestamp = timestamp
1355 
    args.write(self._oprot)
1356 
    self._oprot.writeMessageEnd()
1357 
    self._oprot.trans.flush()
1358 
 
1359 
  def recv_startItemOn(self, ):
1360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1361 
    if mtype == TMessageType.EXCEPTION:
1362 
      x = TApplicationException()
1363 
      x.read(self._iprot)
1364 
      self._iprot.readMessageEnd()
1365 
      raise x
1366 
    result = startItemOn_result()
1367 
    result.read(self._iprot)
1368 
    self._iprot.readMessageEnd()
1369 
    if result.cex is not None:
1370 
      raise result.cex
1371 
    return
1372 
 
1373 
  def retireItemOn(self, item_id, timestamp):
1374 
    """
1375 
    Parameters:
1376 
     - item_id
1377 
     - timestamp
1378 
    """
1379 
    self.send_retireItemOn(item_id, timestamp)
1380 
    self.recv_retireItemOn()
1381 
 
1382 
  def send_retireItemOn(self, item_id, timestamp):
1383 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1384 
    args = retireItemOn_args()
1385 
    args.item_id = item_id
1386 
    args.timestamp = timestamp
1387 
    args.write(self._oprot)
1388 
    self._oprot.writeMessageEnd()
1389 
    self._oprot.trans.flush()
1390 
 
1391 
  def recv_retireItemOn(self, ):
1392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1393 
    if mtype == TMessageType.EXCEPTION:
1394 
      x = TApplicationException()
1395 
      x.read(self._iprot)
1396 
      self._iprot.readMessageEnd()
1397 
      raise x
1398 
    result = retireItemOn_result()
1399 
    result.read(self._iprot)
1400 
    self._iprot.readMessageEnd()
1401 
    if result.cex is not None:
1402 
      raise result.cex
1403 
    return
1404 
 
1405 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1406 
    """
1407 
    Parameters:
1408 
     - item_id
1409 
     - timestamp
1410 
     - newstatus
1411 
    """
1412 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1413 
    self.recv_changeItemStatus()
1414 
 
1415 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1416 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1417 
    args = changeItemStatus_args()
1418 
    args.item_id = item_id
1419 
    args.timestamp = timestamp
1420 
    args.newstatus = newstatus
1421 
    args.write(self._oprot)
1422 
    self._oprot.writeMessageEnd()
1423 
    self._oprot.trans.flush()
1424 
 
1425 
  def recv_changeItemStatus(self, ):
1426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1427 
    if mtype == TMessageType.EXCEPTION:
1428 
      x = TApplicationException()
1429 
      x.read(self._iprot)
1430 
      self._iprot.readMessageEnd()
1431 
      raise x
1432 
    result = changeItemStatus_result()
1433 
    result.read(self._iprot)
1434 
    self._iprot.readMessageEnd()
1435 
    if result.cex is not None:
1436 
      raise result.cex
1437 
    return
1438 
 
1439 
  def getItem(self, item_id):
1440 
    """
1441 
    Parameters:
1442 
     - item_id
1443 
    """
1444 
    self.send_getItem(item_id)
1445 
    return self.recv_getItem()
1446 
 
1447 
  def send_getItem(self, item_id):
1448 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1449 
    args = getItem_args()
1450 
    args.item_id = item_id
1451 
    args.write(self._oprot)
1452 
    self._oprot.writeMessageEnd()
1453 
    self._oprot.trans.flush()
1454 
 
1455 
  def recv_getItem(self, ):
1456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1457 
    if mtype == TMessageType.EXCEPTION:
1458 
      x = TApplicationException()
1459 
      x.read(self._iprot)
1460 
      self._iprot.readMessageEnd()
1461 
      raise x
1462 
    result = getItem_result()
1463 
    result.read(self._iprot)
1464 
    self._iprot.readMessageEnd()
1465 
    if result.success is not None:
1466 
      return result.success
1467 
    if result.cex is not None:
1468 
      raise result.cex
1469 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1470 
 
1471 
  def getItemsByCatalogId(self, catalog_item_id):
1472 
    """
1473 
    Parameters:
1474 
     - catalog_item_id
1475 
    """
1476 
    self.send_getItemsByCatalogId(catalog_item_id)
1477 
    return self.recv_getItemsByCatalogId()
1478 
 
1479 
  def send_getItemsByCatalogId(self, catalog_item_id):
1480 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1481 
    args = getItemsByCatalogId_args()
1482 
    args.catalog_item_id = catalog_item_id
1483 
    args.write(self._oprot)
1484 
    self._oprot.writeMessageEnd()
1485 
    self._oprot.trans.flush()
1486 
 
1487 
  def recv_getItemsByCatalogId(self, ):
1488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1489 
    if mtype == TMessageType.EXCEPTION:
1490 
      x = TApplicationException()
1491 
      x.read(self._iprot)
1492 
      self._iprot.readMessageEnd()
1493 
      raise x
1494 
    result = getItemsByCatalogId_result()
1495 
    result.read(self._iprot)
1496 
    self._iprot.readMessageEnd()
1497 
    if result.success is not None:
1498 
      return result.success
1499 
    if result.cex is not None:
1500 
      raise result.cex
1501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1502 
 
1503 
  def getValidItemsByCatalogId(self, catalog_item_id):
1504 
    """
1505 
    Parameters:
1506 
     - catalog_item_id
1507 
    """
1508 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1509 
    return self.recv_getValidItemsByCatalogId()
1510 
 
1511 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1512 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1513 
    args = getValidItemsByCatalogId_args()
1514 
    args.catalog_item_id = catalog_item_id
1515 
    args.write(self._oprot)
1516 
    self._oprot.writeMessageEnd()
1517 
    self._oprot.trans.flush()
1518 
 
1519 
  def recv_getValidItemsByCatalogId(self, ):
1520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1521 
    if mtype == TMessageType.EXCEPTION:
1522 
      x = TApplicationException()
1523 
      x.read(self._iprot)
1524 
      self._iprot.readMessageEnd()
1525 
      raise x
1526 
    result = getValidItemsByCatalogId_result()
1527 
    result.read(self._iprot)
1528 
    self._iprot.readMessageEnd()
1529 
    if result.success is not None:
1530 
      return result.success
1531 
    if result.cex is not None:
1532 
      raise result.cex
1533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1534 
 
1535 
  def getAllItems(self, isActive):
1536 
    """
1537 
    Parameters:
1538 
     - isActive
1539 
    """
1540 
    self.send_getAllItems(isActive)
1541 
    return self.recv_getAllItems()
1542 
 
1543 
  def send_getAllItems(self, isActive):
1544 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1545 
    args = getAllItems_args()
1546 
    args.isActive = isActive
1547 
    args.write(self._oprot)
1548 
    self._oprot.writeMessageEnd()
1549 
    self._oprot.trans.flush()
1550 
 
1551 
  def recv_getAllItems(self, ):
1552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1553 
    if mtype == TMessageType.EXCEPTION:
1554 
      x = TApplicationException()
1555 
      x.read(self._iprot)
1556 
      self._iprot.readMessageEnd()
1557 
      raise x
1558 
    result = getAllItems_result()
1559 
    result.read(self._iprot)
1560 
    self._iprot.readMessageEnd()
1561 
    if result.success is not None:
1562 
      return result.success
1563 
    if result.cex is not None:
1564 
      raise result.cex
1565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1566 
 
1567 
  def getAllItemsByStatus(self, itemStatus):
1568 
    """
1569 
    Parameters:
1570 
     - itemStatus
1571 
    """
1572 
    self.send_getAllItemsByStatus(itemStatus)
1573 
    return self.recv_getAllItemsByStatus()
1574 
 
1575 
  def send_getAllItemsByStatus(self, itemStatus):
1576 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1577 
    args = getAllItemsByStatus_args()
1578 
    args.itemStatus = itemStatus
1579 
    args.write(self._oprot)
1580 
    self._oprot.writeMessageEnd()
1581 
    self._oprot.trans.flush()
1582 
 
1583 
  def recv_getAllItemsByStatus(self, ):
1584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1585 
    if mtype == TMessageType.EXCEPTION:
1586 
      x = TApplicationException()
1587 
      x.read(self._iprot)
1588 
      self._iprot.readMessageEnd()
1589 
      raise x
1590 
    result = getAllItemsByStatus_result()
1591 
    result.read(self._iprot)
1592 
    self._iprot.readMessageEnd()
1593 
    if result.success is not None:
1594 
      return result.success
1595 
    if result.cex is not None:
1596 
      raise result.cex
1597 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1598 
 
9253 rajveer 1599 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1600 
    """
1601 
    Parameters:
1602 
     - entityId
1603 
     - category
1604 
     - brand
1605 
     - modelName
1606 
     - modelNumber
9253 rajveer 1607 
     - isAndroid
5944 mandeep.dh 1608 
    """
9253 rajveer 1609 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1610 
    return self.recv_markItemAsContentComplete()
1611 
 
9253 rajveer 1612 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1613 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1614 
    args = markItemAsContentComplete_args()
1615 
    args.entityId = entityId
1616 
    args.category = category
1617 
    args.brand = brand
1618 
    args.modelName = modelName
1619 
    args.modelNumber = modelNumber
9253 rajveer 1620 
    args.isAndroid = isAndroid
5944 mandeep.dh 1621 
    args.write(self._oprot)
1622 
    self._oprot.writeMessageEnd()
1623 
    self._oprot.trans.flush()
1624 
 
1625 
  def recv_markItemAsContentComplete(self, ):
1626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1627 
    if mtype == TMessageType.EXCEPTION:
1628 
      x = TApplicationException()
1629 
      x.read(self._iprot)
1630 
      self._iprot.readMessageEnd()
1631 
      raise x
1632 
    result = markItemAsContentComplete_result()
1633 
    result.read(self._iprot)
1634 
    self._iprot.readMessageEnd()
1635 
    if result.success is not None:
1636 
      return result.success
1637 
    if result.cex is not None:
1638 
      raise result.cex
1639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1640 
 
1641 
  def getAllItemsInRange(self, offset, limit):
1642 
    """
1643 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1644 
 
1645 
    Parameters:
1646 
     - offset
1647 
     - limit
1648 
    """
1649 
    self.send_getAllItemsInRange(offset, limit)
1650 
    return self.recv_getAllItemsInRange()
1651 
 
1652 
  def send_getAllItemsInRange(self, offset, limit):
1653 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1654 
    args = getAllItemsInRange_args()
1655 
    args.offset = offset
1656 
    args.limit = limit
1657 
    args.write(self._oprot)
1658 
    self._oprot.writeMessageEnd()
1659 
    self._oprot.trans.flush()
1660 
 
1661 
  def recv_getAllItemsInRange(self, ):
1662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1663 
    if mtype == TMessageType.EXCEPTION:
1664 
      x = TApplicationException()
1665 
      x.read(self._iprot)
1666 
      self._iprot.readMessageEnd()
1667 
      raise x
1668 
    result = getAllItemsInRange_result()
1669 
    result.read(self._iprot)
1670 
    self._iprot.readMessageEnd()
1671 
    if result.success is not None:
1672 
      return result.success
1673 
    if result.cex is not None:
1674 
      raise result.cex
1675 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1676 
 
1677 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1678 
    """
1679 
    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.
1680 
 
1681 
    Parameters:
1682 
     - itemStatus
1683 
     - offset
1684 
     - limit
1685 
    """
1686 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1687 
    return self.recv_getAllItemsByStatusInRange()
1688 
 
1689 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1690 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1691 
    args = getAllItemsByStatusInRange_args()
1692 
    args.itemStatus = itemStatus
1693 
    args.offset = offset
1694 
    args.limit = limit
1695 
    args.write(self._oprot)
1696 
    self._oprot.writeMessageEnd()
1697 
    self._oprot.trans.flush()
1698 
 
1699 
  def recv_getAllItemsByStatusInRange(self, ):
1700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1701 
    if mtype == TMessageType.EXCEPTION:
1702 
      x = TApplicationException()
1703 
      x.read(self._iprot)
1704 
      self._iprot.readMessageEnd()
1705 
      raise x
1706 
    result = getAllItemsByStatusInRange_result()
1707 
    result.read(self._iprot)
1708 
    self._iprot.readMessageEnd()
1709 
    if result.success is not None:
1710 
      return result.success
1711 
    if result.cex is not None:
1712 
      raise result.cex
1713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1714 
 
1715 
  def getItemCountByStatus(self, useStatus, itemStatus):
1716 
    """
1717 
    Gets a count of all items by status
1718 
 
1719 
    Parameters:
1720 
     - useStatus
1721 
     - itemStatus
1722 
    """
1723 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1724 
    return self.recv_getItemCountByStatus()
1725 
 
1726 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1727 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1728 
    args = getItemCountByStatus_args()
1729 
    args.useStatus = useStatus
1730 
    args.itemStatus = itemStatus
1731 
    args.write(self._oprot)
1732 
    self._oprot.writeMessageEnd()
1733 
    self._oprot.trans.flush()
1734 
 
1735 
  def recv_getItemCountByStatus(self, ):
1736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1737 
    if mtype == TMessageType.EXCEPTION:
1738 
      x = TApplicationException()
1739 
      x.read(self._iprot)
1740 
      self._iprot.readMessageEnd()
1741 
      raise x
1742 
    result = getItemCountByStatus_result()
1743 
    result.read(self._iprot)
1744 
    self._iprot.readMessageEnd()
1745 
    if result.success is not None:
1746 
      return result.success
1747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1748 
 
1749 
  def getBestSellers(self, ):
1750 
    self.send_getBestSellers()
1751 
    return self.recv_getBestSellers()
1752 
 
1753 
  def send_getBestSellers(self, ):
1754 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1755 
    args = getBestSellers_args()
1756 
    args.write(self._oprot)
1757 
    self._oprot.writeMessageEnd()
1758 
    self._oprot.trans.flush()
1759 
 
1760 
  def recv_getBestSellers(self, ):
1761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1762 
    if mtype == TMessageType.EXCEPTION:
1763 
      x = TApplicationException()
1764 
      x.read(self._iprot)
1765 
      self._iprot.readMessageEnd()
1766 
      raise x
1767 
    result = getBestSellers_result()
1768 
    result.read(self._iprot)
1769 
    self._iprot.readMessageEnd()
1770 
    if result.success is not None:
1771 
      return result.success
1772 
    if result.isex is not None:
1773 
      raise result.isex
1774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1775 
 
1776 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1777 
    """
1778 
    Parameters:
1779 
     - beginIndex
1780 
     - totalItems
1781 
     - brand
1782 
     - category
1783 
    """
1784 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1785 
    return self.recv_getBestSellersCatalogIds()
1786 
 
1787 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1788 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1789 
    args = getBestSellersCatalogIds_args()
1790 
    args.beginIndex = beginIndex
1791 
    args.totalItems = totalItems
1792 
    args.brand = brand
1793 
    args.category = category
1794 
    args.write(self._oprot)
1795 
    self._oprot.writeMessageEnd()
1796 
    self._oprot.trans.flush()
1797 
 
1798 
  def recv_getBestSellersCatalogIds(self, ):
1799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1800 
    if mtype == TMessageType.EXCEPTION:
1801 
      x = TApplicationException()
1802 
      x.read(self._iprot)
1803 
      self._iprot.readMessageEnd()
1804 
      raise x
1805 
    result = getBestSellersCatalogIds_result()
1806 
    result.read(self._iprot)
1807 
    self._iprot.readMessageEnd()
1808 
    if result.success is not None:
1809 
      return result.success
1810 
    if result.cex is not None:
1811 
      raise result.cex
1812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1813 
 
1814 
  def getBestSellersCount(self, ):
1815 
    self.send_getBestSellersCount()
1816 
    return self.recv_getBestSellersCount()
1817 
 
1818 
  def send_getBestSellersCount(self, ):
1819 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1820 
    args = getBestSellersCount_args()
1821 
    args.write(self._oprot)
1822 
    self._oprot.writeMessageEnd()
1823 
    self._oprot.trans.flush()
1824 
 
1825 
  def recv_getBestSellersCount(self, ):
1826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1827 
    if mtype == TMessageType.EXCEPTION:
1828 
      x = TApplicationException()
1829 
      x.read(self._iprot)
1830 
      self._iprot.readMessageEnd()
1831 
      raise x
1832 
    result = getBestSellersCount_result()
1833 
    result.read(self._iprot)
1834 
    self._iprot.readMessageEnd()
1835 
    if result.success is not None:
1836 
      return result.success
1837 
    if result.cex is not None:
1838 
      raise result.cex
1839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1840 
 
1841 
  def getBestDeals(self, ):
1842 
    self.send_getBestDeals()
1843 
    return self.recv_getBestDeals()
1844 
 
1845 
  def send_getBestDeals(self, ):
1846 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1847 
    args = getBestDeals_args()
1848 
    args.write(self._oprot)
1849 
    self._oprot.writeMessageEnd()
1850 
    self._oprot.trans.flush()
1851 
 
1852 
  def recv_getBestDeals(self, ):
1853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1854 
    if mtype == TMessageType.EXCEPTION:
1855 
      x = TApplicationException()
1856 
      x.read(self._iprot)
1857 
      self._iprot.readMessageEnd()
1858 
      raise x
1859 
    result = getBestDeals_result()
1860 
    result.read(self._iprot)
1861 
    self._iprot.readMessageEnd()
1862 
    if result.success is not None:
1863 
      return result.success
1864 
    if result.isex is not None:
1865 
      raise result.isex
1866 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1867 
 
1868 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1869 
    """
1870 
    Parameters:
1871 
     - beginIndex
1872 
     - totalItems
1873 
     - brand
1874 
     - category
1875 
    """
1876 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1877 
    return self.recv_getBestDealsCatalogIds()
1878 
 
1879 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1880 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1881 
    args = getBestDealsCatalogIds_args()
1882 
    args.beginIndex = beginIndex
1883 
    args.totalItems = totalItems
1884 
    args.brand = brand
1885 
    args.category = category
1886 
    args.write(self._oprot)
1887 
    self._oprot.writeMessageEnd()
1888 
    self._oprot.trans.flush()
1889 
 
1890 
  def recv_getBestDealsCatalogIds(self, ):
1891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1892 
    if mtype == TMessageType.EXCEPTION:
1893 
      x = TApplicationException()
1894 
      x.read(self._iprot)
1895 
      self._iprot.readMessageEnd()
1896 
      raise x
1897 
    result = getBestDealsCatalogIds_result()
1898 
    result.read(self._iprot)
1899 
    self._iprot.readMessageEnd()
1900 
    if result.success is not None:
1901 
      return result.success
1902 
    if result.cex is not None:
1903 
      raise result.cex
1904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1905 
 
1906 
  def getBestDealsCount(self, ):
1907 
    self.send_getBestDealsCount()
1908 
    return self.recv_getBestDealsCount()
1909 
 
1910 
  def send_getBestDealsCount(self, ):
1911 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1912 
    args = getBestDealsCount_args()
1913 
    args.write(self._oprot)
1914 
    self._oprot.writeMessageEnd()
1915 
    self._oprot.trans.flush()
1916 
 
1917 
  def recv_getBestDealsCount(self, ):
1918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1919 
    if mtype == TMessageType.EXCEPTION:
1920 
      x = TApplicationException()
1921 
      x.read(self._iprot)
1922 
      self._iprot.readMessageEnd()
1923 
      raise x
1924 
    result = getBestDealsCount_result()
1925 
    result.read(self._iprot)
1926 
    self._iprot.readMessageEnd()
1927 
    if result.success is not None:
1928 
      return result.success
1929 
    if result.cex is not None:
1930 
      raise result.cex
1931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1932 
 
1933 
  def getComingSoon(self, ):
1934 
    self.send_getComingSoon()
1935 
    return self.recv_getComingSoon()
1936 
 
1937 
  def send_getComingSoon(self, ):
1938 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1939 
    args = getComingSoon_args()
1940 
    args.write(self._oprot)
1941 
    self._oprot.writeMessageEnd()
1942 
    self._oprot.trans.flush()
1943 
 
1944 
  def recv_getComingSoon(self, ):
1945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1946 
    if mtype == TMessageType.EXCEPTION:
1947 
      x = TApplicationException()
1948 
      x.read(self._iprot)
1949 
      self._iprot.readMessageEnd()
1950 
      raise x
1951 
    result = getComingSoon_result()
1952 
    result.read(self._iprot)
1953 
    self._iprot.readMessageEnd()
1954 
    if result.success is not None:
1955 
      return result.success
1956 
    if result.isex is not None:
1957 
      raise result.isex
1958 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1959 
 
1960 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1961 
    """
1962 
    Parameters:
1963 
     - beginIndex
1964 
     - totalItems
1965 
     - brand
1966 
     - category
1967 
    """
1968 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1969 
    return self.recv_getComingSoonCatalogIds()
1970 
 
1971 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1972 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1973 
    args = getComingSoonCatalogIds_args()
1974 
    args.beginIndex = beginIndex
1975 
    args.totalItems = totalItems
1976 
    args.brand = brand
1977 
    args.category = category
1978 
    args.write(self._oprot)
1979 
    self._oprot.writeMessageEnd()
1980 
    self._oprot.trans.flush()
1981 
 
1982 
  def recv_getComingSoonCatalogIds(self, ):
1983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1984 
    if mtype == TMessageType.EXCEPTION:
1985 
      x = TApplicationException()
1986 
      x.read(self._iprot)
1987 
      self._iprot.readMessageEnd()
1988 
      raise x
1989 
    result = getComingSoonCatalogIds_result()
1990 
    result.read(self._iprot)
1991 
    self._iprot.readMessageEnd()
1992 
    if result.success is not None:
1993 
      return result.success
1994 
    if result.cex is not None:
1995 
      raise result.cex
1996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1997 
 
1998 
  def getComingSoonCount(self, ):
1999 
    self.send_getComingSoonCount()
2000 
    return self.recv_getComingSoonCount()
2001 
 
2002 
  def send_getComingSoonCount(self, ):
2003 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
2004 
    args = getComingSoonCount_args()
2005 
    args.write(self._oprot)
2006 
    self._oprot.writeMessageEnd()
2007 
    self._oprot.trans.flush()
2008 
 
2009 
  def recv_getComingSoonCount(self, ):
2010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2011 
    if mtype == TMessageType.EXCEPTION:
2012 
      x = TApplicationException()
2013 
      x.read(self._iprot)
2014 
      self._iprot.readMessageEnd()
2015 
      raise x
2016 
    result = getComingSoonCount_result()
2017 
    result.read(self._iprot)
2018 
    self._iprot.readMessageEnd()
2019 
    if result.success is not None:
2020 
      return result.success
2021 
    if result.cex is not None:
2022 
      raise result.cex
2023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
2024 
 
2025 
  def getLatestArrivals(self, ):
2026 
    """
2027 
    Returns a list of items sorted in the descending order by start date.
2028 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
2029 
    """
2030 
    self.send_getLatestArrivals()
2031 
    return self.recv_getLatestArrivals()
2032 
 
2033 
  def send_getLatestArrivals(self, ):
2034 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
2035 
    args = getLatestArrivals_args()
2036 
    args.write(self._oprot)
2037 
    self._oprot.writeMessageEnd()
2038 
    self._oprot.trans.flush()
2039 
 
2040 
  def recv_getLatestArrivals(self, ):
2041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2042 
    if mtype == TMessageType.EXCEPTION:
2043 
      x = TApplicationException()
2044 
      x.read(self._iprot)
2045 
      self._iprot.readMessageEnd()
2046 
      raise x
2047 
    result = getLatestArrivals_result()
2048 
    result.read(self._iprot)
2049 
    self._iprot.readMessageEnd()
2050 
    if result.success is not None:
2051 
      return result.success
2052 
    if result.isex is not None:
2053 
      raise result.isex
2054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
2055 
 
2056 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2057 
    """
2058 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
2059 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
2060 
 
2061 
    Parameters:
2062 
     - beginIndex
2063 
     - totalItems
2064 
     - brand
2065 
     - categories
2066 
    """
2067 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
2068 
    return self.recv_getLatestArrivalsCatalogIds()
2069 
 
2070 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2071 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
2072 
    args = getLatestArrivalsCatalogIds_args()
2073 
    args.beginIndex = beginIndex
2074 
    args.totalItems = totalItems
2075 
    args.brand = brand
2076 
    args.categories = categories
2077 
    args.write(self._oprot)
2078 
    self._oprot.writeMessageEnd()
2079 
    self._oprot.trans.flush()
2080 
 
2081 
  def recv_getLatestArrivalsCatalogIds(self, ):
2082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2083 
    if mtype == TMessageType.EXCEPTION:
2084 
      x = TApplicationException()
2085 
      x.read(self._iprot)
2086 
      self._iprot.readMessageEnd()
2087 
      raise x
2088 
    result = getLatestArrivalsCatalogIds_result()
2089 
    result.read(self._iprot)
2090 
    self._iprot.readMessageEnd()
2091 
    if result.success is not None:
2092 
      return result.success
2093 
    if result.cex is not None:
2094 
      raise result.cex
2095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
2096 
 
2097 
  def getLatestArrivalsCount(self, ):
2098 
    """
2099 
    Get the total number of latest arrivals we are willing to show.
2100 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
2101 
    """
2102 
    self.send_getLatestArrivalsCount()
2103 
    return self.recv_getLatestArrivalsCount()
2104 
 
2105 
  def send_getLatestArrivalsCount(self, ):
2106 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
2107 
    args = getLatestArrivalsCount_args()
2108 
    args.write(self._oprot)
2109 
    self._oprot.writeMessageEnd()
2110 
    self._oprot.trans.flush()
2111 
 
2112 
  def recv_getLatestArrivalsCount(self, ):
2113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2114 
    if mtype == TMessageType.EXCEPTION:
2115 
      x = TApplicationException()
2116 
      x.read(self._iprot)
2117 
      self._iprot.readMessageEnd()
2118 
      raise x
2119 
    result = getLatestArrivalsCount_result()
2120 
    result.read(self._iprot)
2121 
    self._iprot.readMessageEnd()
2122 
    if result.success is not None:
2123 
      return result.success
2124 
    if result.cex is not None:
2125 
      raise result.cex
2126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
2127 
 
2128 
  def generateNewEntityID(self, ):
2129 
    self.send_generateNewEntityID()
2130 
    return self.recv_generateNewEntityID()
2131 
 
2132 
  def send_generateNewEntityID(self, ):
2133 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2134 
    args = generateNewEntityID_args()
2135 
    args.write(self._oprot)
2136 
    self._oprot.writeMessageEnd()
2137 
    self._oprot.trans.flush()
2138 
 
2139 
  def recv_generateNewEntityID(self, ):
2140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2141 
    if mtype == TMessageType.EXCEPTION:
2142 
      x = TApplicationException()
2143 
      x.read(self._iprot)
2144 
      self._iprot.readMessageEnd()
2145 
      raise x
2146 
    result = generateNewEntityID_result()
2147 
    result.read(self._iprot)
2148 
    self._iprot.readMessageEnd()
2149 
    if result.success is not None:
2150 
      return result.success
2151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2152 
 
2153 
  def addCategory(self, category):
2154 
    """
2155 
    All category related functions
2156 
 
2157 
    Parameters:
2158 
     - category
2159 
    """
2160 
    self.send_addCategory(category)
2161 
    return self.recv_addCategory()
2162 
 
2163 
  def send_addCategory(self, category):
2164 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2165 
    args = addCategory_args()
2166 
    args.category = category
2167 
    args.write(self._oprot)
2168 
    self._oprot.writeMessageEnd()
2169 
    self._oprot.trans.flush()
2170 
 
2171 
  def recv_addCategory(self, ):
2172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2173 
    if mtype == TMessageType.EXCEPTION:
2174 
      x = TApplicationException()
2175 
      x.read(self._iprot)
2176 
      self._iprot.readMessageEnd()
2177 
      raise x
2178 
    result = addCategory_result()
2179 
    result.read(self._iprot)
2180 
    self._iprot.readMessageEnd()
2181 
    if result.success is not None:
2182 
      return result.success
2183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2184 
 
2185 
  def getCategory(self, id):
2186 
    """
2187 
    Parameters:
2188 
     - id
2189 
    """
2190 
    self.send_getCategory(id)
2191 
    return self.recv_getCategory()
2192 
 
2193 
  def send_getCategory(self, id):
2194 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2195 
    args = getCategory_args()
2196 
    args.id = id
2197 
    args.write(self._oprot)
2198 
    self._oprot.writeMessageEnd()
2199 
    self._oprot.trans.flush()
2200 
 
2201 
  def recv_getCategory(self, ):
2202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2203 
    if mtype == TMessageType.EXCEPTION:
2204 
      x = TApplicationException()
2205 
      x.read(self._iprot)
2206 
      self._iprot.readMessageEnd()
2207 
      raise x
2208 
    result = getCategory_result()
2209 
    result.read(self._iprot)
2210 
    self._iprot.readMessageEnd()
2211 
    if result.success is not None:
2212 
      return result.success
2213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2214 
 
2215 
  def getAllCategories(self, ):
2216 
    self.send_getAllCategories()
2217 
    return self.recv_getAllCategories()
2218 
 
2219 
  def send_getAllCategories(self, ):
2220 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2221 
    args = getAllCategories_args()
2222 
    args.write(self._oprot)
2223 
    self._oprot.writeMessageEnd()
2224 
    self._oprot.trans.flush()
2225 
 
2226 
  def recv_getAllCategories(self, ):
2227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2228 
    if mtype == TMessageType.EXCEPTION:
2229 
      x = TApplicationException()
2230 
      x.read(self._iprot)
2231 
      self._iprot.readMessageEnd()
2232 
      raise x
2233 
    result = getAllCategories_result()
2234 
    result.read(self._iprot)
2235 
    self._iprot.readMessageEnd()
2236 
    if result.success is not None:
2237 
      return result.success
2238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2239 
 
2240 
  def getAllSimilarItems(self, itemId):
2241 
    """
2242 
    Returns the list of similar items.
2243 
 
2244 
    Parameters:
2245 
     - itemId
2246 
    """
2247 
    self.send_getAllSimilarItems(itemId)
2248 
    return self.recv_getAllSimilarItems()
2249 
 
2250 
  def send_getAllSimilarItems(self, itemId):
2251 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2252 
    args = getAllSimilarItems_args()
2253 
    args.itemId = itemId
2254 
    args.write(self._oprot)
2255 
    self._oprot.writeMessageEnd()
2256 
    self._oprot.trans.flush()
2257 
 
2258 
  def recv_getAllSimilarItems(self, ):
2259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2260 
    if mtype == TMessageType.EXCEPTION:
2261 
      x = TApplicationException()
2262 
      x.read(self._iprot)
2263 
      self._iprot.readMessageEnd()
2264 
      raise x
2265 
    result = getAllSimilarItems_result()
2266 
    result.read(self._iprot)
2267 
    self._iprot.readMessageEnd()
2268 
    if result.success is not None:
2269 
      return result.success
2270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2271 
 
2272 
  def addSimilarItem(self, itemId, catalogItemId):
2273 
    """
2274 
    Adds similar item.
2275 
 
2276 
    Parameters:
2277 
     - itemId
2278 
     - catalogItemId
2279 
    """
2280 
    self.send_addSimilarItem(itemId, catalogItemId)
2281 
    return self.recv_addSimilarItem()
2282 
 
2283 
  def send_addSimilarItem(self, itemId, catalogItemId):
2284 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2285 
    args = addSimilarItem_args()
2286 
    args.itemId = itemId
2287 
    args.catalogItemId = catalogItemId
2288 
    args.write(self._oprot)
2289 
    self._oprot.writeMessageEnd()
2290 
    self._oprot.trans.flush()
2291 
 
2292 
  def recv_addSimilarItem(self, ):
2293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2294 
    if mtype == TMessageType.EXCEPTION:
2295 
      x = TApplicationException()
2296 
      x.read(self._iprot)
2297 
      self._iprot.readMessageEnd()
2298 
      raise x
2299 
    result = addSimilarItem_result()
2300 
    result.read(self._iprot)
2301 
    self._iprot.readMessageEnd()
2302 
    if result.success is not None:
2303 
      return result.success
2304 
    if result.cex is not None:
2305 
      raise result.cex
2306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2307 
 
6512 kshitij.so 2308 
  def addTag(self, displayName, itemId):
2309 
    """
2310 
    Tag Related
2311 
 
2312 
    Parameters:
2313 
     - displayName
2314 
     - itemId
2315 
    """
2316 
    self.send_addTag(displayName, itemId)
2317 
    return self.recv_addTag()
2318 
 
2319 
  def send_addTag(self, displayName, itemId):
2320 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2321 
    args = addTag_args()
2322 
    args.displayName = displayName
2323 
    args.itemId = itemId
2324 
    args.write(self._oprot)
2325 
    self._oprot.writeMessageEnd()
2326 
    self._oprot.trans.flush()
2327 
 
2328 
  def recv_addTag(self, ):
2329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2330 
    if mtype == TMessageType.EXCEPTION:
2331 
      x = TApplicationException()
2332 
      x.read(self._iprot)
2333 
      self._iprot.readMessageEnd()
2334 
      raise x
2335 
    result = addTag_result()
2336 
    result.read(self._iprot)
2337 
    self._iprot.readMessageEnd()
2338 
    if result.success is not None:
2339 
      return result.success
2340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2341 
 
2342 
  def deleteEntityTag(self, displayName, itemId):
2343 
    """
2344 
    Parameters:
2345 
     - displayName
2346 
     - itemId
2347 
    """
2348 
    self.send_deleteEntityTag(displayName, itemId)
2349 
    return self.recv_deleteEntityTag()
2350 
 
2351 
  def send_deleteEntityTag(self, displayName, itemId):
2352 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2353 
    args = deleteEntityTag_args()
2354 
    args.displayName = displayName
2355 
    args.itemId = itemId
2356 
    args.write(self._oprot)
2357 
    self._oprot.writeMessageEnd()
2358 
    self._oprot.trans.flush()
2359 
 
2360 
  def recv_deleteEntityTag(self, ):
2361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2362 
    if mtype == TMessageType.EXCEPTION:
2363 
      x = TApplicationException()
2364 
      x.read(self._iprot)
2365 
      self._iprot.readMessageEnd()
2366 
      raise x
2367 
    result = deleteEntityTag_result()
2368 
    result.read(self._iprot)
2369 
    self._iprot.readMessageEnd()
2370 
    if result.success is not None:
2371 
      return result.success
2372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2373 
 
2374 
  def deleteTag(self, displayName):
2375 
    """
2376 
    Parameters:
2377 
     - displayName
2378 
    """
2379 
    self.send_deleteTag(displayName)
2380 
    return self.recv_deleteTag()
2381 
 
2382 
  def send_deleteTag(self, displayName):
2383 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2384 
    args = deleteTag_args()
2385 
    args.displayName = displayName
2386 
    args.write(self._oprot)
2387 
    self._oprot.writeMessageEnd()
2388 
    self._oprot.trans.flush()
2389 
 
2390 
  def recv_deleteTag(self, ):
2391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2392 
    if mtype == TMessageType.EXCEPTION:
2393 
      x = TApplicationException()
2394 
      x.read(self._iprot)
2395 
      self._iprot.readMessageEnd()
2396 
      raise x
2397 
    result = deleteTag_result()
2398 
    result.read(self._iprot)
2399 
    self._iprot.readMessageEnd()
2400 
    if result.success is not None:
2401 
      return result.success
2402 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2403 
 
2404 
  def getAllTags(self, ):
2405 
    self.send_getAllTags()
2406 
    return self.recv_getAllTags()
2407 
 
2408 
  def send_getAllTags(self, ):
2409 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2410 
    args = getAllTags_args()
2411 
    args.write(self._oprot)
2412 
    self._oprot.writeMessageEnd()
2413 
    self._oprot.trans.flush()
2414 
 
2415 
  def recv_getAllTags(self, ):
2416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2417 
    if mtype == TMessageType.EXCEPTION:
2418 
      x = TApplicationException()
2419 
      x.read(self._iprot)
2420 
      self._iprot.readMessageEnd()
2421 
      raise x
2422 
    result = getAllTags_result()
2423 
    result.read(self._iprot)
2424 
    self._iprot.readMessageEnd()
2425 
    if result.success is not None:
2426 
      return result.success
2427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2428 
 
2429 
  def getAllEntitiesByTagName(self, displayName):
2430 
    """
2431 
    Parameters:
2432 
     - displayName
2433 
    """
2434 
    self.send_getAllEntitiesByTagName(displayName)
2435 
    return self.recv_getAllEntitiesByTagName()
2436 
 
2437 
  def send_getAllEntitiesByTagName(self, displayName):
2438 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2439 
    args = getAllEntitiesByTagName_args()
2440 
    args.displayName = displayName
2441 
    args.write(self._oprot)
2442 
    self._oprot.writeMessageEnd()
2443 
    self._oprot.trans.flush()
2444 
 
2445 
  def recv_getAllEntitiesByTagName(self, ):
2446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2447 
    if mtype == TMessageType.EXCEPTION:
2448 
      x = TApplicationException()
2449 
      x.read(self._iprot)
2450 
      self._iprot.readMessageEnd()
2451 
      raise x
2452 
    result = getAllEntitiesByTagName_result()
2453 
    result.read(self._iprot)
2454 
    self._iprot.readMessageEnd()
2455 
    if result.success is not None:
2456 
      return result.success
2457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2458 
 
6845 amit.gupta 2459 
  def getAllEntityTags(self, ):
2460 
    self.send_getAllEntityTags()
2461 
    return self.recv_getAllEntityTags()
2462 
 
2463 
  def send_getAllEntityTags(self, ):
2464 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2465 
    args = getAllEntityTags_args()
2466 
    args.write(self._oprot)
2467 
    self._oprot.writeMessageEnd()
2468 
    self._oprot.trans.flush()
2469 
 
2470 
  def recv_getAllEntityTags(self, ):
2471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2472 
    if mtype == TMessageType.EXCEPTION:
2473 
      x = TApplicationException()
2474 
      x.read(self._iprot)
2475 
      self._iprot.readMessageEnd()
2476 
      raise x
2477 
    result = getAllEntityTags_result()
2478 
    result.read(self._iprot)
2479 
    self._iprot.readMessageEnd()
2480 
    if result.success is not None:
2481 
      return result.success
2482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2483 
 
8590 kshitij.so 2484 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2485 
    """
8579 kshitij.so 2486 
    Banner Related
2487 
 
6850 kshitij.so 2488 
    Parameters:
8590 kshitij.so 2489 
     - bannerCongregate
6850 kshitij.so 2490 
    """
8590 kshitij.so 2491 
    self.send_addBanner(bannerCongregate)
10097 kshitij.so 2492 
    return self.recv_addBanner()
6850 kshitij.so 2493 
 
8590 kshitij.so 2494 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2495 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2496 
    args = addBanner_args()
8590 kshitij.so 2497 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2498 
    args.write(self._oprot)
2499 
    self._oprot.writeMessageEnd()
2500 
    self._oprot.trans.flush()
2501 
 
2502 
  def recv_addBanner(self, ):
2503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2504 
    if mtype == TMessageType.EXCEPTION:
2505 
      x = TApplicationException()
2506 
      x.read(self._iprot)
2507 
      self._iprot.readMessageEnd()
2508 
      raise x
2509 
    result = addBanner_result()
2510 
    result.read(self._iprot)
2511 
    self._iprot.readMessageEnd()
10097 kshitij.so 2512 
    if result.success is not None:
2513 
      return result.success
2514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
6850 kshitij.so 2515 
 
8579 kshitij.so 2516 
  def updateBanner(self, banner):
2517 
    """
2518 
    Parameters:
2519 
     - banner
2520 
    """
2521 
    self.send_updateBanner(banner)
2522 
    return self.recv_updateBanner()
2523 
 
2524 
  def send_updateBanner(self, banner):
2525 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2526 
    args = updateBanner_args()
2527 
    args.banner = banner
2528 
    args.write(self._oprot)
2529 
    self._oprot.writeMessageEnd()
2530 
    self._oprot.trans.flush()
2531 
 
2532 
  def recv_updateBanner(self, ):
2533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2534 
    if mtype == TMessageType.EXCEPTION:
2535 
      x = TApplicationException()
2536 
      x.read(self._iprot)
2537 
      self._iprot.readMessageEnd()
2538 
      raise x
2539 
    result = updateBanner_result()
2540 
    result.read(self._iprot)
2541 
    self._iprot.readMessageEnd()
2542 
    if result.success is not None:
2543 
      return result.success
2544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2545 
 
6850 kshitij.so 2546 
  def getAllBanners(self, ):
2547 
    self.send_getAllBanners()
2548 
    return self.recv_getAllBanners()
2549 
 
2550 
  def send_getAllBanners(self, ):
2551 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2552 
    args = getAllBanners_args()
2553 
    args.write(self._oprot)
2554 
    self._oprot.writeMessageEnd()
2555 
    self._oprot.trans.flush()
2556 
 
2557 
  def recv_getAllBanners(self, ):
2558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2559 
    if mtype == TMessageType.EXCEPTION:
2560 
      x = TApplicationException()
2561 
      x.read(self._iprot)
2562 
      self._iprot.readMessageEnd()
2563 
      raise x
2564 
    result = getAllBanners_result()
2565 
    result.read(self._iprot)
2566 
    self._iprot.readMessageEnd()
2567 
    if result.success is not None:
2568 
      return result.success
2569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2570 
 
9155 kshitij.so 2571 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2572 
    """
2573 
    Parameters:
2574 
     - bannerName
9155 kshitij.so 2575 
     - bannerType
6850 kshitij.so 2576 
    """
9155 kshitij.so 2577 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2578 
    return self.recv_deleteBanner()
2579 
 
9155 kshitij.so 2580 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2581 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2582 
    args = deleteBanner_args()
2583 
    args.bannerName = bannerName
9155 kshitij.so 2584 
    args.bannerType = bannerType
6850 kshitij.so 2585 
    args.write(self._oprot)
2586 
    self._oprot.writeMessageEnd()
2587 
    self._oprot.trans.flush()
2588 
 
2589 
  def recv_deleteBanner(self, ):
2590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2591 
    if mtype == TMessageType.EXCEPTION:
2592 
      x = TApplicationException()
2593 
      x.read(self._iprot)
2594 
      self._iprot.readMessageEnd()
2595 
      raise x
2596 
    result = deleteBanner_result()
2597 
    result.read(self._iprot)
2598 
    self._iprot.readMessageEnd()
2599 
    if result.success is not None:
2600 
      return result.success
2601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2602 
 
9155 kshitij.so 2603 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2604 
    """
2605 
    Parameters:
2606 
     - bannerName
9155 kshitij.so 2607 
     - bannerType
6850 kshitij.so 2608 
    """
9155 kshitij.so 2609 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2610 
    return self.recv_getBannerDetails()
2611 
 
9155 kshitij.so 2612 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2613 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2614 
    args = getBannerDetails_args()
2615 
    args.bannerName = bannerName
9155 kshitij.so 2616 
    args.bannerType = bannerType
6850 kshitij.so 2617 
    args.write(self._oprot)
2618 
    self._oprot.writeMessageEnd()
2619 
    self._oprot.trans.flush()
2620 
 
2621 
  def recv_getBannerDetails(self, ):
2622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2623 
    if mtype == TMessageType.EXCEPTION:
2624 
      x = TApplicationException()
2625 
      x.read(self._iprot)
2626 
      self._iprot.readMessageEnd()
2627 
      raise x
2628 
    result = getBannerDetails_result()
2629 
    result.read(self._iprot)
2630 
    self._iprot.readMessageEnd()
2631 
    if result.success is not None:
2632 
      return result.success
2633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2634 
 
2635 
  def getActiveBanners(self, ):
2636 
    self.send_getActiveBanners()
2637 
    return self.recv_getActiveBanners()
2638 
 
2639 
  def send_getActiveBanners(self, ):
2640 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2641 
    args = getActiveBanners_args()
2642 
    args.write(self._oprot)
2643 
    self._oprot.writeMessageEnd()
2644 
    self._oprot.trans.flush()
2645 
 
2646 
  def recv_getActiveBanners(self, ):
2647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2648 
    if mtype == TMessageType.EXCEPTION:
2649 
      x = TApplicationException()
2650 
      x.read(self._iprot)
2651 
      self._iprot.readMessageEnd()
2652 
      raise x
2653 
    result = getActiveBanners_result()
2654 
    result.read(self._iprot)
2655 
    self._iprot.readMessageEnd()
2656 
    if result.success is not None:
2657 
      return result.success
2658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2659 
 
8579 kshitij.so 2660 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2661 
    """
2662 
    Parameters:
8579 kshitij.so 2663 
     - bannerMaps
6849 kshitij.so 2664 
    """
8579 kshitij.so 2665 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2666 
    return self.recv_addBannerMap()
2667 
 
8579 kshitij.so 2668 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2669 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2670 
    args = addBannerMap_args()
8579 kshitij.so 2671 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2672 
    args.write(self._oprot)
2673 
    self._oprot.writeMessageEnd()
2674 
    self._oprot.trans.flush()
2675 
 
2676 
  def recv_addBannerMap(self, ):
2677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2678 
    if mtype == TMessageType.EXCEPTION:
2679 
      x = TApplicationException()
2680 
      x.read(self._iprot)
2681 
      self._iprot.readMessageEnd()
2682 
      raise x
2683 
    result = addBannerMap_result()
2684 
    result.read(self._iprot)
2685 
    self._iprot.readMessageEnd()
2686 
    if result.success is not None:
2687 
      return result.success
2688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2689 
 
8579 kshitij.so 2690 
  def updateBannerMap(self, bannerMap):
2691 
    """
2692 
    Parameters:
2693 
     - bannerMap
2694 
    """
2695 
    self.send_updateBannerMap(bannerMap)
2696 
    return self.recv_updateBannerMap()
2697 
 
2698 
  def send_updateBannerMap(self, bannerMap):
2699 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2700 
    args = updateBannerMap_args()
2701 
    args.bannerMap = bannerMap
2702 
    args.write(self._oprot)
2703 
    self._oprot.writeMessageEnd()
2704 
    self._oprot.trans.flush()
2705 
 
2706 
  def recv_updateBannerMap(self, ):
2707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2708 
    if mtype == TMessageType.EXCEPTION:
2709 
      x = TApplicationException()
2710 
      x.read(self._iprot)
2711 
      self._iprot.readMessageEnd()
2712 
      raise x
2713 
    result = updateBannerMap_result()
2714 
    result.read(self._iprot)
2715 
    self._iprot.readMessageEnd()
2716 
    if result.success is not None:
2717 
      return result.success
2718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2719 
 
6849 kshitij.so 2720 
  def deleteBannerMap(self, bannerName):
2721 
    """
2722 
    Parameters:
2723 
     - bannerName
2724 
    """
2725 
    self.send_deleteBannerMap(bannerName)
2726 
    return self.recv_deleteBannerMap()
2727 
 
2728 
  def send_deleteBannerMap(self, bannerName):
2729 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2730 
    args = deleteBannerMap_args()
2731 
    args.bannerName = bannerName
2732 
    args.write(self._oprot)
2733 
    self._oprot.writeMessageEnd()
2734 
    self._oprot.trans.flush()
2735 
 
2736 
  def recv_deleteBannerMap(self, ):
2737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2738 
    if mtype == TMessageType.EXCEPTION:
2739 
      x = TApplicationException()
2740 
      x.read(self._iprot)
2741 
      self._iprot.readMessageEnd()
2742 
      raise x
2743 
    result = deleteBannerMap_result()
2744 
    result.read(self._iprot)
2745 
    self._iprot.readMessageEnd()
2746 
    if result.success is not None:
2747 
      return result.success
2748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2749 
 
9155 kshitij.so 2750 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2751 
    """
2752 
    Parameters:
2753 
     - bannerName
9155 kshitij.so 2754 
     - bannerType
6849 kshitij.so 2755 
    """
9155 kshitij.so 2756 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2757 
    return self.recv_getBannerMapDetails()
2758 
 
9155 kshitij.so 2759 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2760 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2761 
    args = getBannerMapDetails_args()
2762 
    args.bannerName = bannerName
9155 kshitij.so 2763 
    args.bannerType = bannerType
6849 kshitij.so 2764 
    args.write(self._oprot)
2765 
    self._oprot.writeMessageEnd()
2766 
    self._oprot.trans.flush()
2767 
 
2768 
  def recv_getBannerMapDetails(self, ):
2769 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2770 
    if mtype == TMessageType.EXCEPTION:
2771 
      x = TApplicationException()
2772 
      x.read(self._iprot)
2773 
      self._iprot.readMessageEnd()
2774 
      raise x
2775 
    result = getBannerMapDetails_result()
2776 
    result.read(self._iprot)
2777 
    self._iprot.readMessageEnd()
2778 
    if result.success is not None:
2779 
      return result.success
2780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2781 
 
8579 kshitij.so 2782 
  def addBannerUri(self, bannerUriMappings):
2783 
    """
2784 
    Parameters:
2785 
     - bannerUriMappings
2786 
    """
2787 
    self.send_addBannerUri(bannerUriMappings)
2788 
    self.recv_addBannerUri()
2789 
 
2790 
  def send_addBannerUri(self, bannerUriMappings):
2791 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2792 
    args = addBannerUri_args()
2793 
    args.bannerUriMappings = bannerUriMappings
2794 
    args.write(self._oprot)
2795 
    self._oprot.writeMessageEnd()
2796 
    self._oprot.trans.flush()
2797 
 
2798 
  def recv_addBannerUri(self, ):
2799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2800 
    if mtype == TMessageType.EXCEPTION:
2801 
      x = TApplicationException()
2802 
      x.read(self._iprot)
2803 
      self._iprot.readMessageEnd()
2804 
      raise x
2805 
    result = addBannerUri_result()
2806 
    result.read(self._iprot)
2807 
    self._iprot.readMessageEnd()
2808 
    return
2809 
 
9155 kshitij.so 2810 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2811 
    """
2812 
    Parameters:
2813 
     - bannerName
9155 kshitij.so 2814 
     - bannerType
8579 kshitij.so 2815 
    """
9155 kshitij.so 2816 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2817 
    return self.recv_getUriMapping()
2818 
 
9155 kshitij.so 2819 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2820 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2821 
    args = getUriMapping_args()
2822 
    args.bannerName = bannerName
9155 kshitij.so 2823 
    args.bannerType = bannerType
8579 kshitij.so 2824 
    args.write(self._oprot)
2825 
    self._oprot.writeMessageEnd()
2826 
    self._oprot.trans.flush()
2827 
 
2828 
  def recv_getUriMapping(self, ):
2829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2830 
    if mtype == TMessageType.EXCEPTION:
2831 
      x = TApplicationException()
2832 
      x.read(self._iprot)
2833 
      self._iprot.readMessageEnd()
2834 
      raise x
2835 
    result = getUriMapping_result()
2836 
    result.read(self._iprot)
2837 
    self._iprot.readMessageEnd()
2838 
    if result.success is not None:
2839 
      return result.success
2840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2841 
 
2842 
  def addCampaign(self, campaign):
2843 
    """
2844 
    Parameters:
2845 
     - campaign
2846 
    """
2847 
    self.send_addCampaign(campaign)
2848 
    self.recv_addCampaign()
2849 
 
2850 
  def send_addCampaign(self, campaign):
2851 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2852 
    args = addCampaign_args()
2853 
    args.campaign = campaign
2854 
    args.write(self._oprot)
2855 
    self._oprot.writeMessageEnd()
2856 
    self._oprot.trans.flush()
2857 
 
2858 
  def recv_addCampaign(self, ):
2859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2860 
    if mtype == TMessageType.EXCEPTION:
2861 
      x = TApplicationException()
2862 
      x.read(self._iprot)
2863 
      self._iprot.readMessageEnd()
2864 
      raise x
2865 
    result = addCampaign_result()
2866 
    result.read(self._iprot)
2867 
    self._iprot.readMessageEnd()
2868 
    return
2869 
 
2870 
  def getCampaigns(self, campaignName):
2871 
    """
2872 
    Parameters:
2873 
     - campaignName
2874 
    """
2875 
    self.send_getCampaigns(campaignName)
2876 
    return self.recv_getCampaigns()
2877 
 
2878 
  def send_getCampaigns(self, campaignName):
2879 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2880 
    args = getCampaigns_args()
2881 
    args.campaignName = campaignName
2882 
    args.write(self._oprot)
2883 
    self._oprot.writeMessageEnd()
2884 
    self._oprot.trans.flush()
2885 
 
2886 
  def recv_getCampaigns(self, ):
2887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2888 
    if mtype == TMessageType.EXCEPTION:
2889 
      x = TApplicationException()
2890 
      x.read(self._iprot)
2891 
      self._iprot.readMessageEnd()
2892 
      raise x
2893 
    result = getCampaigns_result()
2894 
    result.read(self._iprot)
2895 
    self._iprot.readMessageEnd()
2896 
    if result.success is not None:
2897 
      return result.success
2898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2899 
 
2900 
  def deleteCampaign(self, campaignId):
2901 
    """
2902 
    Parameters:
2903 
     - campaignId
2904 
    """
2905 
    self.send_deleteCampaign(campaignId)
2906 
    self.recv_deleteCampaign()
2907 
 
2908 
  def send_deleteCampaign(self, campaignId):
2909 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2910 
    args = deleteCampaign_args()
2911 
    args.campaignId = campaignId
2912 
    args.write(self._oprot)
2913 
    self._oprot.writeMessageEnd()
2914 
    self._oprot.trans.flush()
2915 
 
2916 
  def recv_deleteCampaign(self, ):
2917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2918 
    if mtype == TMessageType.EXCEPTION:
2919 
      x = TApplicationException()
2920 
      x.read(self._iprot)
2921 
      self._iprot.readMessageEnd()
2922 
      raise x
2923 
    result = deleteCampaign_result()
2924 
    result.read(self._iprot)
2925 
    self._iprot.readMessageEnd()
2926 
    return
2927 
 
2928 
  def getAllCampaigns(self, ):
2929 
    self.send_getAllCampaigns()
2930 
    return self.recv_getAllCampaigns()
2931 
 
2932 
  def send_getAllCampaigns(self, ):
2933 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2934 
    args = getAllCampaigns_args()
2935 
    args.write(self._oprot)
2936 
    self._oprot.writeMessageEnd()
2937 
    self._oprot.trans.flush()
2938 
 
2939 
  def recv_getAllCampaigns(self, ):
2940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2941 
    if mtype == TMessageType.EXCEPTION:
2942 
      x = TApplicationException()
2943 
      x.read(self._iprot)
2944 
      self._iprot.readMessageEnd()
2945 
      raise x
2946 
    result = getAllCampaigns_result()
2947 
    result.read(self._iprot)
2948 
    self._iprot.readMessageEnd()
2949 
    if result.success is not None:
2950 
      return result.success
2951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2952 
 
9155 kshitij.so 2953 
  def getActiveBannersForMobileSite(self, ):
2954 
    self.send_getActiveBannersForMobileSite()
2955 
    return self.recv_getActiveBannersForMobileSite()
2956 
 
2957 
  def send_getActiveBannersForMobileSite(self, ):
2958 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2959 
    args = getActiveBannersForMobileSite_args()
2960 
    args.write(self._oprot)
2961 
    self._oprot.writeMessageEnd()
2962 
    self._oprot.trans.flush()
2963 
 
2964 
  def recv_getActiveBannersForMobileSite(self, ):
2965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2966 
    if mtype == TMessageType.EXCEPTION:
2967 
      x = TApplicationException()
2968 
      x.read(self._iprot)
2969 
      self._iprot.readMessageEnd()
2970 
      raise x
2971 
    result = getActiveBannersForMobileSite_result()
2972 
    result.read(self._iprot)
2973 
    self._iprot.readMessageEnd()
2974 
    if result.success is not None:
2975 
      return result.success
2976 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2977 
 
5944 mandeep.dh 2978 
  def deleteSimilarItem(self, itemId, catalogItemId):
2979 
    """
2980 
    Delete similar item.
2981 
 
2982 
    Parameters:
2983 
     - itemId
2984 
     - catalogItemId
2985 
    """
2986 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2987 
    return self.recv_deleteSimilarItem()
2988 
 
2989 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2990 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2991 
    args = deleteSimilarItem_args()
2992 
    args.itemId = itemId
2993 
    args.catalogItemId = catalogItemId
2994 
    args.write(self._oprot)
2995 
    self._oprot.writeMessageEnd()
2996 
    self._oprot.trans.flush()
2997 
 
2998 
  def recv_deleteSimilarItem(self, ):
2999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3000 
    if mtype == TMessageType.EXCEPTION:
3001 
      x = TApplicationException()
3002 
      x.read(self._iprot)
3003 
      self._iprot.readMessageEnd()
3004 
      raise x
3005 
    result = deleteSimilarItem_result()
3006 
    result.read(self._iprot)
3007 
    self._iprot.readMessageEnd()
3008 
    if result.success is not None:
3009 
      return result.success
3010 
    if result.cex is not None:
3011 
      raise result.cex
3012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
3013 
 
3014 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
3015 
    """
3016 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
3017 
    If yes, returns the itemId else returns 0
3018 
 
3019 
    Parameters:
3020 
     - brand
3021 
     - modelNumber
3022 
     - modelName
3023 
     - color
3024 
    """
3025 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
3026 
    return self.recv_checkSimilarItem()
3027 
 
3028 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
3029 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
3030 
    args = checkSimilarItem_args()
3031 
    args.brand = brand
3032 
    args.modelNumber = modelNumber
3033 
    args.modelName = modelName
3034 
    args.color = color
3035 
    args.write(self._oprot)
3036 
    self._oprot.writeMessageEnd()
3037 
    self._oprot.trans.flush()
3038 
 
3039 
  def recv_checkSimilarItem(self, ):
3040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3041 
    if mtype == TMessageType.EXCEPTION:
3042 
      x = TApplicationException()
3043 
      x.read(self._iprot)
3044 
      self._iprot.readMessageEnd()
3045 
      raise x
3046 
    result = checkSimilarItem_result()
3047 
    result.read(self._iprot)
3048 
    self._iprot.readMessageEnd()
3049 
    if result.success is not None:
3050 
      return result.success
3051 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
3052 
 
3053 
  def validateRiskyStatus(self, itemId):
3054 
    """
3055 
    Check wether item is risky and change status if inventory is not available for risky items
3056 
 
3057 
    Parameters:
3058 
     - itemId
3059 
    """
3060 
    self.send_validateRiskyStatus(itemId)
3061 
    self.recv_validateRiskyStatus()
3062 
 
3063 
  def send_validateRiskyStatus(self, itemId):
3064 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
3065 
    args = validateRiskyStatus_args()
3066 
    args.itemId = itemId
3067 
    args.write(self._oprot)
3068 
    self._oprot.writeMessageEnd()
3069 
    self._oprot.trans.flush()
3070 
 
3071 
  def recv_validateRiskyStatus(self, ):
3072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3073 
    if mtype == TMessageType.EXCEPTION:
3074 
      x = TApplicationException()
3075 
      x.read(self._iprot)
3076 
      self._iprot.readMessageEnd()
3077 
      raise x
3078 
    result = validateRiskyStatus_result()
3079 
    result.read(self._iprot)
3080 
    self._iprot.readMessageEnd()
3081 
    return
3082 
 
3083 
  def changeItemRiskyFlag(self, itemId, risky):
3084 
    """
3085 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
3086 
 
3087 
    Parameters:
3088 
     - itemId
3089 
     - risky
3090 
    """
3091 
    self.send_changeItemRiskyFlag(itemId, risky)
3092 
    self.recv_changeItemRiskyFlag()
3093 
 
3094 
  def send_changeItemRiskyFlag(self, itemId, risky):
3095 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
3096 
    args = changeItemRiskyFlag_args()
3097 
    args.itemId = itemId
3098 
    args.risky = risky
3099 
    args.write(self._oprot)
3100 
    self._oprot.writeMessageEnd()
3101 
    self._oprot.trans.flush()
3102 
 
3103 
  def recv_changeItemRiskyFlag(self, ):
3104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3105 
    if mtype == TMessageType.EXCEPTION:
3106 
      x = TApplicationException()
3107 
      x.read(self._iprot)
3108 
      self._iprot.readMessageEnd()
3109 
      raise x
3110 
    result = changeItemRiskyFlag_result()
3111 
    result.read(self._iprot)
3112 
    self._iprot.readMessageEnd()
3113 
    return
3114 
 
3115 
  def getItemsByRiskyFlag(self, ):
3116 
    """
3117 
    Returns list of items marked as risky.
3118 
    """
3119 
    self.send_getItemsByRiskyFlag()
3120 
    return self.recv_getItemsByRiskyFlag()
3121 
 
3122 
  def send_getItemsByRiskyFlag(self, ):
3123 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
3124 
    args = getItemsByRiskyFlag_args()
3125 
    args.write(self._oprot)
3126 
    self._oprot.writeMessageEnd()
3127 
    self._oprot.trans.flush()
3128 
 
3129 
  def recv_getItemsByRiskyFlag(self, ):
3130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3131 
    if mtype == TMessageType.EXCEPTION:
3132 
      x = TApplicationException()
3133 
      x.read(self._iprot)
3134 
      self._iprot.readMessageEnd()
3135 
      raise x
3136 
    result = getItemsByRiskyFlag_result()
3137 
    result.read(self._iprot)
3138 
    self._iprot.readMessageEnd()
3139 
    if result.success is not None:
3140 
      return result.success
3141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
3142 
 
3143 
  def getItemsForMasterSheet(self, category, brand):
3144 
    """
3145 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3146 
 
3147 
    Parameters:
3148 
     - category
3149 
     - brand
3150 
    """
3151 
    self.send_getItemsForMasterSheet(category, brand)
3152 
    return self.recv_getItemsForMasterSheet()
3153 
 
3154 
  def send_getItemsForMasterSheet(self, category, brand):
3155 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3156 
    args = getItemsForMasterSheet_args()
3157 
    args.category = category
3158 
    args.brand = brand
3159 
    args.write(self._oprot)
3160 
    self._oprot.writeMessageEnd()
3161 
    self._oprot.trans.flush()
3162 
 
3163 
  def recv_getItemsForMasterSheet(self, ):
3164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3165 
    if mtype == TMessageType.EXCEPTION:
3166 
      x = TApplicationException()
3167 
      x.read(self._iprot)
3168 
      self._iprot.readMessageEnd()
3169 
      raise x
3170 
    result = getItemsForMasterSheet_result()
3171 
    result.read(self._iprot)
3172 
    self._iprot.readMessageEnd()
3173 
    if result.success is not None:
3174 
      return result.success
3175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3176 
 
3177 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3178 
    """
3179 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3180 
 
3181 
    Parameters:
3182 
     - beginIndex
3183 
     - totalItems
3184 
     - itemId
3185 
    """
3186 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3187 
    return self.recv_getSimilarItemsCatalogIds()
3188 
 
3189 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3190 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3191 
    args = getSimilarItemsCatalogIds_args()
3192 
    args.beginIndex = beginIndex
3193 
    args.totalItems = totalItems
3194 
    args.itemId = itemId
3195 
    args.write(self._oprot)
3196 
    self._oprot.writeMessageEnd()
3197 
    self._oprot.trans.flush()
3198 
 
3199 
  def recv_getSimilarItemsCatalogIds(self, ):
3200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3201 
    if mtype == TMessageType.EXCEPTION:
3202 
      x = TApplicationException()
3203 
      x.read(self._iprot)
3204 
      self._iprot.readMessageEnd()
3205 
      raise x
3206 
    result = getSimilarItemsCatalogIds_result()
3207 
    result.read(self._iprot)
3208 
    self._iprot.readMessageEnd()
3209 
    if result.success is not None:
3210 
      return result.success
3211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3212 
 
3213 
  def addProductNotification(self, itemId, email):
3214 
    """
3215 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3216 
 
3217 
    Parameters:
3218 
     - itemId
3219 
     - email
3220 
    """
3221 
    self.send_addProductNotification(itemId, email)
3222 
    return self.recv_addProductNotification()
3223 
 
3224 
  def send_addProductNotification(self, itemId, email):
3225 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3226 
    args = addProductNotification_args()
3227 
    args.itemId = itemId
3228 
    args.email = email
3229 
    args.write(self._oprot)
3230 
    self._oprot.writeMessageEnd()
3231 
    self._oprot.trans.flush()
3232 
 
3233 
  def recv_addProductNotification(self, ):
3234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3235 
    if mtype == TMessageType.EXCEPTION:
3236 
      x = TApplicationException()
3237 
      x.read(self._iprot)
3238 
      self._iprot.readMessageEnd()
3239 
      raise x
3240 
    result = addProductNotification_result()
3241 
    result.read(self._iprot)
3242 
    self._iprot.readMessageEnd()
3243 
    if result.success is not None:
3244 
      return result.success
3245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3246 
 
3247 
  def sendProductNotifications(self, ):
3248 
    """
3249 
    Send the product notifications to the users for items which has stock.
3250 
    """
3251 
    self.send_sendProductNotifications()
3252 
    return self.recv_sendProductNotifications()
3253 
 
3254 
  def send_sendProductNotifications(self, ):
3255 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3256 
    args = sendProductNotifications_args()
3257 
    args.write(self._oprot)
3258 
    self._oprot.writeMessageEnd()
3259 
    self._oprot.trans.flush()
3260 
 
3261 
  def recv_sendProductNotifications(self, ):
3262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3263 
    if mtype == TMessageType.EXCEPTION:
3264 
      x = TApplicationException()
3265 
      x.read(self._iprot)
3266 
      self._iprot.readMessageEnd()
3267 
      raise x
3268 
    result = sendProductNotifications_result()
3269 
    result.read(self._iprot)
3270 
    self._iprot.readMessageEnd()
3271 
    if result.success is not None:
3272 
      return result.success
3273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3274 
 
3275 
  def getAllBrandsByCategory(self, categoryId):
3276 
    """
3277 
    Returns list of brand names for a given category Id
3278 
 
3279 
    Parameters:
3280 
     - categoryId
3281 
    """
3282 
    self.send_getAllBrandsByCategory(categoryId)
3283 
    return self.recv_getAllBrandsByCategory()
3284 
 
3285 
  def send_getAllBrandsByCategory(self, categoryId):
3286 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3287 
    args = getAllBrandsByCategory_args()
3288 
    args.categoryId = categoryId
3289 
    args.write(self._oprot)
3290 
    self._oprot.writeMessageEnd()
3291 
    self._oprot.trans.flush()
3292 
 
3293 
  def recv_getAllBrandsByCategory(self, ):
3294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3295 
    if mtype == TMessageType.EXCEPTION:
3296 
      x = TApplicationException()
3297 
      x.read(self._iprot)
3298 
      self._iprot.readMessageEnd()
3299 
      raise x
3300 
    result = getAllBrandsByCategory_result()
3301 
    result.read(self._iprot)
3302 
    self._iprot.readMessageEnd()
3303 
    if result.success is not None:
3304 
      return result.success
3305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3306 
 
3307 
  def getAllBrands(self, ):
3308 
    """
3309 
    Returns list of brand names
3310 
    """
3311 
    self.send_getAllBrands()
3312 
    return self.recv_getAllBrands()
3313 
 
3314 
  def send_getAllBrands(self, ):
3315 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3316 
    args = getAllBrands_args()
3317 
    args.write(self._oprot)
3318 
    self._oprot.writeMessageEnd()
3319 
    self._oprot.trans.flush()
3320 
 
3321 
  def recv_getAllBrands(self, ):
3322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3323 
    if mtype == TMessageType.EXCEPTION:
3324 
      x = TApplicationException()
3325 
      x.read(self._iprot)
3326 
      self._iprot.readMessageEnd()
3327 
      raise x
3328 
    result = getAllBrands_result()
3329 
    result.read(self._iprot)
3330 
    self._iprot.readMessageEnd()
3331 
    if result.success is not None:
3332 
      return result.success
3333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3334 
 
3335 
  def getAllSources(self, ):
3336 
    """
3337 
    Return list of all sources
3338 
    """
3339 
    self.send_getAllSources()
3340 
    return self.recv_getAllSources()
3341 
 
3342 
  def send_getAllSources(self, ):
3343 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3344 
    args = getAllSources_args()
3345 
    args.write(self._oprot)
3346 
    self._oprot.writeMessageEnd()
3347 
    self._oprot.trans.flush()
3348 
 
3349 
  def recv_getAllSources(self, ):
3350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3351 
    if mtype == TMessageType.EXCEPTION:
3352 
      x = TApplicationException()
3353 
      x.read(self._iprot)
3354 
      self._iprot.readMessageEnd()
3355 
      raise x
3356 
    result = getAllSources_result()
3357 
    result.read(self._iprot)
3358 
    self._iprot.readMessageEnd()
3359 
    if result.success is not None:
3360 
      return result.success
3361 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3362 
 
3363 
  def getItemPricingBySource(self, itemId, sourceId):
3364 
    """
3365 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3366 
 
3367 
    Parameters:
3368 
     - itemId
3369 
     - sourceId
3370 
    """
3371 
    self.send_getItemPricingBySource(itemId, sourceId)
3372 
    return self.recv_getItemPricingBySource()
3373 
 
3374 
  def send_getItemPricingBySource(self, itemId, sourceId):
3375 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3376 
    args = getItemPricingBySource_args()
3377 
    args.itemId = itemId
3378 
    args.sourceId = sourceId
3379 
    args.write(self._oprot)
3380 
    self._oprot.writeMessageEnd()
3381 
    self._oprot.trans.flush()
3382 
 
3383 
  def recv_getItemPricingBySource(self, ):
3384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3385 
    if mtype == TMessageType.EXCEPTION:
3386 
      x = TApplicationException()
3387 
      x.read(self._iprot)
3388 
      self._iprot.readMessageEnd()
3389 
      raise x
3390 
    result = getItemPricingBySource_result()
3391 
    result.read(self._iprot)
3392 
    self._iprot.readMessageEnd()
3393 
    if result.success is not None:
3394 
      return result.success
3395 
    if result.cex is not None:
3396 
      raise result.cex
3397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3398 
 
3399 
  def addSourceItemPricing(self, sourceItemPricing):
3400 
    """
3401 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3402 
    If item is not found or source is not found, it will throw exception.
3403 
 
3404 
    Parameters:
3405 
     - sourceItemPricing
3406 
    """
3407 
    self.send_addSourceItemPricing(sourceItemPricing)
3408 
    self.recv_addSourceItemPricing()
3409 
 
3410 
  def send_addSourceItemPricing(self, sourceItemPricing):
3411 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3412 
    args = addSourceItemPricing_args()
3413 
    args.sourceItemPricing = sourceItemPricing
3414 
    args.write(self._oprot)
3415 
    self._oprot.writeMessageEnd()
3416 
    self._oprot.trans.flush()
3417 
 
3418 
  def recv_addSourceItemPricing(self, ):
3419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3420 
    if mtype == TMessageType.EXCEPTION:
3421 
      x = TApplicationException()
3422 
      x.read(self._iprot)
3423 
      self._iprot.readMessageEnd()
3424 
      raise x
3425 
    result = addSourceItemPricing_result()
3426 
    result.read(self._iprot)
3427 
    self._iprot.readMessageEnd()
3428 
    if result.cex is not None:
3429 
      raise result.cex
3430 
    return
3431 
 
3432 
  def getAllSourcePricing(self, itemId):
3433 
    """
3434 
    Returns the list of source pricing information of an item.
3435 
    Raises an exception if item not found corresponding to itemId
3436 
 
3437 
    Parameters:
3438 
     - itemId
3439 
    """
3440 
    self.send_getAllSourcePricing(itemId)
3441 
    return self.recv_getAllSourcePricing()
3442 
 
3443 
  def send_getAllSourcePricing(self, itemId):
3444 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3445 
    args = getAllSourcePricing_args()
3446 
    args.itemId = itemId
3447 
    args.write(self._oprot)
3448 
    self._oprot.writeMessageEnd()
3449 
    self._oprot.trans.flush()
3450 
 
3451 
  def recv_getAllSourcePricing(self, ):
3452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3453 
    if mtype == TMessageType.EXCEPTION:
3454 
      x = TApplicationException()
3455 
      x.read(self._iprot)
3456 
      self._iprot.readMessageEnd()
3457 
      raise x
3458 
    result = getAllSourcePricing_result()
3459 
    result.read(self._iprot)
3460 
    self._iprot.readMessageEnd()
3461 
    if result.success is not None:
3462 
      return result.success
3463 
    if result.cex is not None:
3464 
      raise result.cex
3465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3466 
 
3467 
  def getItemForSource(self, item_id, sourceId):
3468 
    """
3469 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3470 
 
3471 
    Parameters:
3472 
     - item_id
3473 
     - sourceId
3474 
    """
3475 
    self.send_getItemForSource(item_id, sourceId)
3476 
    return self.recv_getItemForSource()
3477 
 
3478 
  def send_getItemForSource(self, item_id, sourceId):
3479 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3480 
    args = getItemForSource_args()
3481 
    args.item_id = item_id
3482 
    args.sourceId = sourceId
3483 
    args.write(self._oprot)
3484 
    self._oprot.writeMessageEnd()
3485 
    self._oprot.trans.flush()
3486 
 
3487 
  def recv_getItemForSource(self, ):
3488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3489 
    if mtype == TMessageType.EXCEPTION:
3490 
      x = TApplicationException()
3491 
      x.read(self._iprot)
3492 
      self._iprot.readMessageEnd()
3493 
      raise x
3494 
    result = getItemForSource_result()
3495 
    result.read(self._iprot)
3496 
    self._iprot.readMessageEnd()
3497 
    if result.success is not None:
3498 
      return result.success
3499 
    if result.cex is not None:
3500 
      raise result.cex
3501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3502 
 
3503 
  def searchItemsInRange(self, searchTerms, offset, limit):
3504 
    """
3505 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3506 
 
3507 
    Parameters:
3508 
     - searchTerms
3509 
     - offset
3510 
     - limit
3511 
    """
3512 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3513 
    return self.recv_searchItemsInRange()
3514 
 
3515 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3516 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3517 
    args = searchItemsInRange_args()
3518 
    args.searchTerms = searchTerms
3519 
    args.offset = offset
3520 
    args.limit = limit
3521 
    args.write(self._oprot)
3522 
    self._oprot.writeMessageEnd()
3523 
    self._oprot.trans.flush()
3524 
 
3525 
  def recv_searchItemsInRange(self, ):
3526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3527 
    if mtype == TMessageType.EXCEPTION:
3528 
      x = TApplicationException()
3529 
      x.read(self._iprot)
3530 
      self._iprot.readMessageEnd()
3531 
      raise x
3532 
    result = searchItemsInRange_result()
3533 
    result.read(self._iprot)
3534 
    self._iprot.readMessageEnd()
3535 
    if result.success is not None:
3536 
      return result.success
3537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3538 
 
3539 
  def getSearchResultCount(self, searchTerms):
3540 
    """
3541 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3542 
 
3543 
    Parameters:
3544 
     - searchTerms
3545 
    """
3546 
    self.send_getSearchResultCount(searchTerms)
3547 
    return self.recv_getSearchResultCount()
3548 
 
3549 
  def send_getSearchResultCount(self, searchTerms):
3550 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3551 
    args = getSearchResultCount_args()
3552 
    args.searchTerms = searchTerms
3553 
    args.write(self._oprot)
3554 
    self._oprot.writeMessageEnd()
3555 
    self._oprot.trans.flush()
3556 
 
3557 
  def recv_getSearchResultCount(self, ):
3558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3559 
    if mtype == TMessageType.EXCEPTION:
3560 
      x = TApplicationException()
3561 
      x.read(self._iprot)
3562 
      self._iprot.readMessageEnd()
3563 
      raise x
3564 
    result = getSearchResultCount_result()
3565 
    result.read(self._iprot)
3566 
    self._iprot.readMessageEnd()
3567 
    if result.success is not None:
3568 
      return result.success
3569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3570 
 
3571 
  def getProductNotifications(self, startDateTime):
3572 
    """
3573 
    Returns a list of product notifications added after a supplied datetime
3574 
 
3575 
    Parameters:
3576 
     - startDateTime
3577 
    """
3578 
    self.send_getProductNotifications(startDateTime)
3579 
    return self.recv_getProductNotifications()
3580 
 
3581 
  def send_getProductNotifications(self, startDateTime):
3582 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3583 
    args = getProductNotifications_args()
3584 
    args.startDateTime = startDateTime
3585 
    args.write(self._oprot)
3586 
    self._oprot.writeMessageEnd()
3587 
    self._oprot.trans.flush()
3588 
 
3589 
  def recv_getProductNotifications(self, ):
3590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3591 
    if mtype == TMessageType.EXCEPTION:
3592 
      x = TApplicationException()
3593 
      x.read(self._iprot)
3594 
      self._iprot.readMessageEnd()
3595 
      raise x
3596 
    result = getProductNotifications_result()
3597 
    result.read(self._iprot)
3598 
    self._iprot.readMessageEnd()
3599 
    if result.success is not None:
3600 
      return result.success
3601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3602 
 
7897 amar.kumar 3603 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3604 
    """
3605 
    Returns a list of count of requests for product notification against each item
3606 
 
3607 
    Parameters:
3608 
     - startDateTime
7897 amar.kumar 3609 
     - categoryId
5944 mandeep.dh 3610 
    """
7897 amar.kumar 3611 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3612 
    return self.recv_getProductNotificationRequestCount()
3613 
 
7897 amar.kumar 3614 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3615 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3616 
    args = getProductNotificationRequestCount_args()
3617 
    args.startDateTime = startDateTime
7897 amar.kumar 3618 
    args.categoryId = categoryId
5944 mandeep.dh 3619 
    args.write(self._oprot)
3620 
    self._oprot.writeMessageEnd()
3621 
    self._oprot.trans.flush()
3622 
 
3623 
  def recv_getProductNotificationRequestCount(self, ):
3624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3625 
    if mtype == TMessageType.EXCEPTION:
3626 
      x = TApplicationException()
3627 
      x.read(self._iprot)
3628 
      self._iprot.readMessageEnd()
3629 
      raise x
3630 
    result = getProductNotificationRequestCount_result()
3631 
    result.read(self._iprot)
3632 
    self._iprot.readMessageEnd()
3633 
    if result.success is not None:
3634 
      return result.success
3635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3636 
 
3637 
  def addAuthorizationLog(self, itemId, username, reason):
3638 
    """
3639 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3640 
 
3641 
    Parameters:
3642 
     - itemId
3643 
     - username
3644 
     - reason
3645 
    """
3646 
    self.send_addAuthorizationLog(itemId, username, reason)
3647 
    return self.recv_addAuthorizationLog()
3648 
 
3649 
  def send_addAuthorizationLog(self, itemId, username, reason):
3650 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3651 
    args = addAuthorizationLog_args()
3652 
    args.itemId = itemId
3653 
    args.username = username
3654 
    args.reason = reason
3655 
    args.write(self._oprot)
3656 
    self._oprot.writeMessageEnd()
3657 
    self._oprot.trans.flush()
3658 
 
3659 
  def recv_addAuthorizationLog(self, ):
3660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3661 
    if mtype == TMessageType.EXCEPTION:
3662 
      x = TApplicationException()
3663 
      x.read(self._iprot)
3664 
      self._iprot.readMessageEnd()
3665 
      raise x
3666 
    result = addAuthorizationLog_result()
3667 
    result.read(self._iprot)
3668 
    self._iprot.readMessageEnd()
3669 
    if result.success is not None:
3670 
      return result.success
3671 
    if result.cex is not None:
3672 
      raise result.cex
3673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3674 
 
3675 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3676 
    """
3677 
    Parameters:
3678 
     - catalog_item_id
3679 
     - voucherType
3680 
     - voucherAmount
3681 
    """
3682 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3683 
    return self.recv_addupdateVoucherForItem()
3684 
 
3685 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3686 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3687 
    args = addupdateVoucherForItem_args()
3688 
    args.catalog_item_id = catalog_item_id
3689 
    args.voucherType = voucherType
3690 
    args.voucherAmount = voucherAmount
3691 
    args.write(self._oprot)
3692 
    self._oprot.writeMessageEnd()
3693 
    self._oprot.trans.flush()
3694 
 
3695 
  def recv_addupdateVoucherForItem(self, ):
3696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3697 
    if mtype == TMessageType.EXCEPTION:
3698 
      x = TApplicationException()
3699 
      x.read(self._iprot)
3700 
      self._iprot.readMessageEnd()
3701 
      raise x
3702 
    result = addupdateVoucherForItem_result()
3703 
    result.read(self._iprot)
3704 
    self._iprot.readMessageEnd()
3705 
    if result.success is not None:
3706 
      return result.success
3707 
    if result.cex is not None:
3708 
      raise result.cex
3709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3710 
 
3711 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3712 
    """
3713 
    Parameters:
3714 
     - catalog_item_id
3715 
     - voucherType
3716 
    """
3717 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3718 
    return self.recv_deleteVoucherForItem()
3719 
 
3720 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3721 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3722 
    args = deleteVoucherForItem_args()
3723 
    args.catalog_item_id = catalog_item_id
3724 
    args.voucherType = voucherType
3725 
    args.write(self._oprot)
3726 
    self._oprot.writeMessageEnd()
3727 
    self._oprot.trans.flush()
3728 
 
3729 
  def recv_deleteVoucherForItem(self, ):
3730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3731 
    if mtype == TMessageType.EXCEPTION:
3732 
      x = TApplicationException()
3733 
      x.read(self._iprot)
3734 
      self._iprot.readMessageEnd()
3735 
      raise x
3736 
    result = deleteVoucherForItem_result()
3737 
    result.read(self._iprot)
3738 
    self._iprot.readMessageEnd()
3739 
    if result.success is not None:
3740 
      return result.success
3741 
    if result.cex is not None:
3742 
      raise result.cex
3743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3744 
 
3745 
  def getVoucherAmount(self, itemId, voucherType):
3746 
    """
3747 
    Parameters:
3748 
     - itemId
3749 
     - voucherType
3750 
    """
3751 
    self.send_getVoucherAmount(itemId, voucherType)
3752 
    return self.recv_getVoucherAmount()
3753 
 
3754 
  def send_getVoucherAmount(self, itemId, voucherType):
3755 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3756 
    args = getVoucherAmount_args()
3757 
    args.itemId = itemId
3758 
    args.voucherType = voucherType
3759 
    args.write(self._oprot)
3760 
    self._oprot.writeMessageEnd()
3761 
    self._oprot.trans.flush()
3762 
 
3763 
  def recv_getVoucherAmount(self, ):
3764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3765 
    if mtype == TMessageType.EXCEPTION:
3766 
      x = TApplicationException()
3767 
      x.read(self._iprot)
3768 
      self._iprot.readMessageEnd()
3769 
      raise x
3770 
    result = getVoucherAmount_result()
3771 
    result.read(self._iprot)
3772 
    self._iprot.readMessageEnd()
3773 
    if result.success is not None:
3774 
      return result.success
3775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3776 
 
3777 
  def getAllItemVouchers(self, itemId):
3778 
    """
3779 
    Parameters:
3780 
     - itemId
3781 
    """
3782 
    self.send_getAllItemVouchers(itemId)
3783 
    return self.recv_getAllItemVouchers()
3784 
 
3785 
  def send_getAllItemVouchers(self, itemId):
3786 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3787 
    args = getAllItemVouchers_args()
3788 
    args.itemId = itemId
3789 
    args.write(self._oprot)
3790 
    self._oprot.writeMessageEnd()
3791 
    self._oprot.trans.flush()
3792 
 
3793 
  def recv_getAllItemVouchers(self, ):
3794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3795 
    if mtype == TMessageType.EXCEPTION:
3796 
      x = TApplicationException()
3797 
      x.read(self._iprot)
3798 
      self._iprot.readMessageEnd()
3799 
      raise x
3800 
    result = getAllItemVouchers_result()
3801 
    result.read(self._iprot)
3802 
    self._iprot.readMessageEnd()
3803 
    if result.success is not None:
3804 
      return result.success
3805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3806 
 
3807 
  def isValidCatalogItemId(self, catalog_item_id):
3808 
    """
3809 
    Parameters:
3810 
     - catalog_item_id
3811 
    """
3812 
    self.send_isValidCatalogItemId(catalog_item_id)
3813 
    return self.recv_isValidCatalogItemId()
3814 
 
3815 
  def send_isValidCatalogItemId(self, catalog_item_id):
3816 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3817 
    args = isValidCatalogItemId_args()
3818 
    args.catalog_item_id = catalog_item_id
3819 
    args.write(self._oprot)
3820 
    self._oprot.writeMessageEnd()
3821 
    self._oprot.trans.flush()
3822 
 
3823 
  def recv_isValidCatalogItemId(self, ):
3824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3825 
    if mtype == TMessageType.EXCEPTION:
3826 
      x = TApplicationException()
3827 
      x.read(self._iprot)
3828 
      self._iprot.readMessageEnd()
3829 
      raise x
3830 
    result = isValidCatalogItemId_result()
3831 
    result.read(self._iprot)
3832 
    self._iprot.readMessageEnd()
3833 
    if result.success is not None:
3834 
      return result.success
3835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3836 
 
7330 amit.gupta 3837 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3838 
    """
3839 
    Parameters:
3840 
     - itemId
7330 amit.gupta 3841 
     - stateId
6039 amit.gupta 3842 
     - price
3843 
    """
7330 amit.gupta 3844 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3845 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3846 
 
7330 amit.gupta 3847 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3848 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3849 
    args = getVatPercentageForItem_args()
3850 
    args.itemId = itemId
7330 amit.gupta 3851 
    args.stateId = stateId
6039 amit.gupta 3852 
    args.price = price
3853 
    args.write(self._oprot)
3854 
    self._oprot.writeMessageEnd()
3855 
    self._oprot.trans.flush()
3856 
 
3857 
  def recv_getVatPercentageForItem(self, ):
3858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3859 
    if mtype == TMessageType.EXCEPTION:
3860 
      x = TApplicationException()
3861 
      x.read(self._iprot)
3862 
      self._iprot.readMessageEnd()
3863 
      raise x
3864 
    result = getVatPercentageForItem_result()
3865 
    result.read(self._iprot)
3866 
    self._iprot.readMessageEnd()
3867 
    if result.success is not None:
3868 
      return result.success
7340 amit.gupta 3869 
    if result.cex is not None:
3870 
      raise result.cex
6039 amit.gupta 3871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3872 
 
3873 
  def getVatAmountForItem(self, itemId, price):
3874 
    """
3875 
    Parameters:
3876 
     - itemId
3877 
     - price
3878 
    """
3879 
    self.send_getVatAmountForItem(itemId, price)
3880 
    return self.recv_getVatAmountForItem()
3881 
 
3882 
  def send_getVatAmountForItem(self, itemId, price):
3883 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3884 
    args = getVatAmountForItem_args()
3885 
    args.itemId = itemId
3886 
    args.price = price
3887 
    args.write(self._oprot)
3888 
    self._oprot.writeMessageEnd()
3889 
    self._oprot.trans.flush()
3890 
 
3891 
  def recv_getVatAmountForItem(self, ):
3892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3893 
    if mtype == TMessageType.EXCEPTION:
3894 
      x = TApplicationException()
3895 
      x.read(self._iprot)
3896 
      self._iprot.readMessageEnd()
3897 
      raise x
3898 
    result = getVatAmountForItem_result()
3899 
    result.read(self._iprot)
3900 
    self._iprot.readMessageEnd()
3901 
    if result.success is not None:
3902 
      return result.success
3903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3904 
 
6531 vikram.rag 3905 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3906 
    """
3907 
    Parameters:
3908 
     - offset
3909 
     - limit
3910 
    """
3911 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3912 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3913 
 
6531 vikram.rag 3914 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3915 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3916 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3917 
    args.offset = offset
3918 
    args.limit = limit
3919 
    args.write(self._oprot)
3920 
    self._oprot.writeMessageEnd()
3921 
    self._oprot.trans.flush()
3922 
 
3923 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3925 
    if mtype == TMessageType.EXCEPTION:
3926 
      x = TApplicationException()
3927 
      x.read(self._iprot)
3928 
      self._iprot.readMessageEnd()
3929 
      raise x
3930 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3931 
    result.read(self._iprot)
3932 
    self._iprot.readMessageEnd()
3933 
    if result.success is not None:
3934 
      return result.success
3935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3936 
 
6821 amar.kumar 3937 
  def getAllAliveItems(self, ):
3938 
    self.send_getAllAliveItems()
3939 
    return self.recv_getAllAliveItems()
3940 
 
3941 
  def send_getAllAliveItems(self, ):
3942 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3943 
    args = getAllAliveItems_args()
3944 
    args.write(self._oprot)
3945 
    self._oprot.writeMessageEnd()
3946 
    self._oprot.trans.flush()
3947 
 
3948 
  def recv_getAllAliveItems(self, ):
3949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3950 
    if mtype == TMessageType.EXCEPTION:
3951 
      x = TApplicationException()
3952 
      x.read(self._iprot)
3953 
      self._iprot.readMessageEnd()
3954 
      raise x
3955 
    result = getAllAliveItems_result()
3956 
    result.read(self._iprot)
3957 
    self._iprot.readMessageEnd()
3958 
    if result.success is not None:
3959 
      return result.success
3960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3961 
 
6921 anupam.sin 3962 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3963 
    """
3964 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3965 
 
6805 anupam.sin 3966 
    Parameters:
3967 
     - itemId
6921 anupam.sin 3968 
     - price
6805 anupam.sin 3969 
     - insurerId
3970 
     - quantity
3971 
    """
6921 anupam.sin 3972 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3973 
    return self.recv_getInsuranceAmount()
3974 
 
6921 anupam.sin 3975 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3976 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3977 
    args = getInsuranceAmount_args()
3978 
    args.itemId = itemId
6921 anupam.sin 3979 
    args.price = price
6805 anupam.sin 3980 
    args.insurerId = insurerId
3981 
    args.quantity = quantity
3982 
    args.write(self._oprot)
3983 
    self._oprot.writeMessageEnd()
3984 
    self._oprot.trans.flush()
3985 
 
3986 
  def recv_getInsuranceAmount(self, ):
3987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3988 
    if mtype == TMessageType.EXCEPTION:
3989 
      x = TApplicationException()
3990 
      x.read(self._iprot)
3991 
      self._iprot.readMessageEnd()
3992 
      raise x
3993 
    result = getInsuranceAmount_result()
3994 
    result.read(self._iprot)
3995 
    self._iprot.readMessageEnd()
3996 
    if result.success is not None:
3997 
      return result.success
3998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3999 
 
4000 
  def getInsurer(self, insurerId):
4001 
    """
4002 
    Parameters:
4003 
     - insurerId
4004 
    """
4005 
    self.send_getInsurer(insurerId)
4006 
    return self.recv_getInsurer()
4007 
 
4008 
  def send_getInsurer(self, insurerId):
4009 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
4010 
    args = getInsurer_args()
4011 
    args.insurerId = insurerId
4012 
    args.write(self._oprot)
4013 
    self._oprot.writeMessageEnd()
4014 
    self._oprot.trans.flush()
4015 
 
4016 
  def recv_getInsurer(self, ):
4017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4018 
    if mtype == TMessageType.EXCEPTION:
4019 
      x = TApplicationException()
4020 
      x.read(self._iprot)
4021 
      self._iprot.readMessageEnd()
4022 
      raise x
4023 
    result = getInsurer_result()
4024 
    result.read(self._iprot)
4025 
    self._iprot.readMessageEnd()
4026 
    if result.success is not None:
4027 
      return result.success
4028 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
4029 
 
6838 vikram.rag 4030 
  def getAllInsurers(self, ):
4031 
    self.send_getAllInsurers()
4032 
    return self.recv_getAllInsurers()
6805 anupam.sin 4033 
 
6838 vikram.rag 4034 
  def send_getAllInsurers(self, ):
4035 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
4036 
    args = getAllInsurers_args()
4037 
    args.write(self._oprot)
4038 
    self._oprot.writeMessageEnd()
4039 
    self._oprot.trans.flush()
4040 
 
4041 
  def recv_getAllInsurers(self, ):
4042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4043 
    if mtype == TMessageType.EXCEPTION:
4044 
      x = TApplicationException()
4045 
      x.read(self._iprot)
4046 
      self._iprot.readMessageEnd()
4047 
      raise x
4048 
    result = getAllInsurers_result()
4049 
    result.read(self._iprot)
4050 
    self._iprot.readMessageEnd()
4051 
    if result.success is not None:
4052 
      return result.success
4053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
4054 
 
6962 rajveer 4055 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
4056 
    """
4057 
    Parameters:
4058 
     - insurerId
4059 
     - amount
4060 
    """
4061 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
4062 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 4063 
 
6962 rajveer 4064 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
4065 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
4066 
    args = updateInsuranceDeclaredAmount_args()
4067 
    args.insurerId = insurerId
4068 
    args.amount = amount
4069 
    args.write(self._oprot)
4070 
    self._oprot.writeMessageEnd()
4071 
    self._oprot.trans.flush()
4072 
 
4073 
  def recv_updateInsuranceDeclaredAmount(self, ):
4074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4075 
    if mtype == TMessageType.EXCEPTION:
4076 
      x = TApplicationException()
4077 
      x.read(self._iprot)
4078 
      self._iprot.readMessageEnd()
4079 
      raise x
4080 
    result = updateInsuranceDeclaredAmount_result()
4081 
    result.read(self._iprot)
4082 
    self._iprot.readMessageEnd()
4083 
    return
4084 
 
7190 amar.kumar 4085 
  def getFreebieForItem(self, itemId):
4086 
    """
4087 
    Parameters:
4088 
     - itemId
4089 
    """
4090 
    self.send_getFreebieForItem(itemId)
4091 
    return self.recv_getFreebieForItem()
6962 rajveer 4092 
 
7190 amar.kumar 4093 
  def send_getFreebieForItem(self, itemId):
4094 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
4095 
    args = getFreebieForItem_args()
4096 
    args.itemId = itemId
4097 
    args.write(self._oprot)
4098 
    self._oprot.writeMessageEnd()
4099 
    self._oprot.trans.flush()
4100 
 
4101 
  def recv_getFreebieForItem(self, ):
4102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4103 
    if mtype == TMessageType.EXCEPTION:
4104 
      x = TApplicationException()
4105 
      x.read(self._iprot)
4106 
      self._iprot.readMessageEnd()
4107 
      raise x
4108 
    result = getFreebieForItem_result()
4109 
    result.read(self._iprot)
4110 
    self._iprot.readMessageEnd()
4111 
    if result.success is not None:
4112 
      return result.success
4113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
4114 
 
4115 
  def addOrUpdateFreebieForItem(self, freebieItem):
4116 
    """
4117 
    Parameters:
4118 
     - freebieItem
4119 
    """
4120 
    self.send_addOrUpdateFreebieForItem(freebieItem)
4121 
    self.recv_addOrUpdateFreebieForItem()
4122 
 
4123 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
4124 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
4125 
    args = addOrUpdateFreebieForItem_args()
4126 
    args.freebieItem = freebieItem
4127 
    args.write(self._oprot)
4128 
    self._oprot.writeMessageEnd()
4129 
    self._oprot.trans.flush()
4130 
 
4131 
  def recv_addOrUpdateFreebieForItem(self, ):
4132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4133 
    if mtype == TMessageType.EXCEPTION:
4134 
      x = TApplicationException()
4135 
      x.read(self._iprot)
4136 
      self._iprot.readMessageEnd()
4137 
      raise x
4138 
    result = addOrUpdateFreebieForItem_result()
4139 
    result.read(self._iprot)
4140 
    self._iprot.readMessageEnd()
4141 
    return
4142 
 
7272 amit.gupta 4143 
  def addOrUpdateBrandInfo(self, brandInfo):
4144 
    """
4145 
    Parameters:
4146 
     - brandInfo
4147 
    """
4148 
    self.send_addOrUpdateBrandInfo(brandInfo)
4149 
    self.recv_addOrUpdateBrandInfo()
4150 
 
4151 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4152 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4153 
    args = addOrUpdateBrandInfo_args()
4154 
    args.brandInfo = brandInfo
4155 
    args.write(self._oprot)
4156 
    self._oprot.writeMessageEnd()
4157 
    self._oprot.trans.flush()
4158 
 
4159 
  def recv_addOrUpdateBrandInfo(self, ):
4160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4161 
    if mtype == TMessageType.EXCEPTION:
4162 
      x = TApplicationException()
4163 
      x.read(self._iprot)
4164 
      self._iprot.readMessageEnd()
4165 
      raise x
4166 
    result = addOrUpdateBrandInfo_result()
4167 
    result.read(self._iprot)
4168 
    self._iprot.readMessageEnd()
4169 
    return
4170 
 
4171 
  def getBrandInfo(self, ):
4172 
    self.send_getBrandInfo()
4173 
    return self.recv_getBrandInfo()
4174 
 
4175 
  def send_getBrandInfo(self, ):
4176 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4177 
    args = getBrandInfo_args()
4178 
    args.write(self._oprot)
4179 
    self._oprot.writeMessageEnd()
4180 
    self._oprot.trans.flush()
4181 
 
4182 
  def recv_getBrandInfo(self, ):
4183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4184 
    if mtype == TMessageType.EXCEPTION:
4185 
      x = TApplicationException()
4186 
      x.read(self._iprot)
4187 
      self._iprot.readMessageEnd()
4188 
      raise x
4189 
    result = getBrandInfo_result()
4190 
    result.read(self._iprot)
4191 
    self._iprot.readMessageEnd()
4192 
    if result.success is not None:
4193 
      return result.success
4194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4195 
 
7256 rajveer 4196 
  def getStorePricing(self, itemId):
4197 
    """
4198 
    Parameters:
4199 
     - itemId
4200 
    """
4201 
    self.send_getStorePricing(itemId)
4202 
    return self.recv_getStorePricing()
7190 amar.kumar 4203 
 
7256 rajveer 4204 
  def send_getStorePricing(self, itemId):
4205 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4206 
    args = getStorePricing_args()
4207 
    args.itemId = itemId
4208 
    args.write(self._oprot)
4209 
    self._oprot.writeMessageEnd()
4210 
    self._oprot.trans.flush()
4211 
 
4212 
  def recv_getStorePricing(self, ):
4213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4214 
    if mtype == TMessageType.EXCEPTION:
4215 
      x = TApplicationException()
4216 
      x.read(self._iprot)
4217 
      self._iprot.readMessageEnd()
4218 
      raise x
4219 
    result = getStorePricing_result()
4220 
    result.read(self._iprot)
4221 
    self._iprot.readMessageEnd()
4222 
    if result.success is not None:
4223 
      return result.success
4224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4225 
 
7306 rajveer 4226 
  def getStorePricings(self, itemIds):
4227 
    """
4228 
    Parameters:
4229 
     - itemIds
4230 
    """
4231 
    self.send_getStorePricings(itemIds)
4232 
    return self.recv_getStorePricings()
4233 
 
4234 
  def send_getStorePricings(self, itemIds):
4235 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4236 
    args = getStorePricings_args()
4237 
    args.itemIds = itemIds
4238 
    args.write(self._oprot)
4239 
    self._oprot.writeMessageEnd()
4240 
    self._oprot.trans.flush()
4241 
 
4242 
  def recv_getStorePricings(self, ):
4243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4244 
    if mtype == TMessageType.EXCEPTION:
4245 
      x = TApplicationException()
4246 
      x.read(self._iprot)
4247 
      self._iprot.readMessageEnd()
4248 
      raise x
4249 
    result = getStorePricings_result()
4250 
    result.read(self._iprot)
4251 
    self._iprot.readMessageEnd()
4252 
    if result.success is not None:
4253 
      return result.success
4254 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4255 
 
7382 rajveer 4256 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4257 
    """
4258 
    Parameters:
4259 
     - sp
7382 rajveer 4260 
     - allColors
7265 rajveer 4261 
    """
7382 rajveer 4262 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4263 
    self.recv_updateStorePricing()
7256 rajveer 4264 
 
7382 rajveer 4265 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4266 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4267 
    args = updateStorePricing_args()
4268 
    args.sp = sp
7382 rajveer 4269 
    args.allColors = allColors
7265 rajveer 4270 
    args.write(self._oprot)
4271 
    self._oprot.writeMessageEnd()
4272 
    self._oprot.trans.flush()
4273 
 
4274 
  def recv_updateStorePricing(self, ):
4275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4276 
    if mtype == TMessageType.EXCEPTION:
4277 
      x = TApplicationException()
4278 
      x.read(self._iprot)
4279 
      self._iprot.readMessageEnd()
4280 
      raise x
4281 
    result = updateStorePricing_result()
4282 
    result.read(self._iprot)
4283 
    self._iprot.readMessageEnd()
4284 
    return
4285 
 
7281 kshitij.so 4286 
  def getAllAmazonListedItems(self, ):
4287 
    self.send_getAllAmazonListedItems()
4288 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4289 
 
7281 kshitij.so 4290 
  def send_getAllAmazonListedItems(self, ):
4291 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4292 
    args = getAllAmazonListedItems_args()
4293 
    args.write(self._oprot)
4294 
    self._oprot.writeMessageEnd()
4295 
    self._oprot.trans.flush()
4296 
 
4297 
  def recv_getAllAmazonListedItems(self, ):
4298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4299 
    if mtype == TMessageType.EXCEPTION:
4300 
      x = TApplicationException()
4301 
      x.read(self._iprot)
4302 
      self._iprot.readMessageEnd()
4303 
      raise x
4304 
    result = getAllAmazonListedItems_result()
4305 
    result.read(self._iprot)
4306 
    self._iprot.readMessageEnd()
4307 
    if result.success is not None:
4308 
      return result.success
4309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4310 
 
8619 kshitij.so 4311 
  def searchAmazonItems(self, searchTerm, offset, limit):
4312 
    """
4313 
    Parameters:
4314 
     - searchTerm
4315 
     - offset
4316 
     - limit
4317 
    """
4318 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4319 
    return self.recv_searchAmazonItems()
4320 
 
4321 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4322 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4323 
    args = searchAmazonItems_args()
4324 
    args.searchTerm = searchTerm
4325 
    args.offset = offset
4326 
    args.limit = limit
4327 
    args.write(self._oprot)
4328 
    self._oprot.writeMessageEnd()
4329 
    self._oprot.trans.flush()
4330 
 
4331 
  def recv_searchAmazonItems(self, ):
4332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4333 
    if mtype == TMessageType.EXCEPTION:
4334 
      x = TApplicationException()
4335 
      x.read(self._iprot)
4336 
      self._iprot.readMessageEnd()
4337 
      raise x
4338 
    result = searchAmazonItems_result()
4339 
    result.read(self._iprot)
4340 
    self._iprot.readMessageEnd()
4341 
    if result.success is not None:
4342 
      return result.success
4343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4344 
 
4345 
  def getAmazonSearchResultCount(self, searchTerm):
4346 
    """
4347 
    Parameters:
4348 
     - searchTerm
4349 
    """
4350 
    self.send_getAmazonSearchResultCount(searchTerm)
4351 
    return self.recv_getAmazonSearchResultCount()
4352 
 
4353 
  def send_getAmazonSearchResultCount(self, searchTerm):
4354 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4355 
    args = getAmazonSearchResultCount_args()
4356 
    args.searchTerm = searchTerm
4357 
    args.write(self._oprot)
4358 
    self._oprot.writeMessageEnd()
4359 
    self._oprot.trans.flush()
4360 
 
4361 
  def recv_getAmazonSearchResultCount(self, ):
4362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4363 
    if mtype == TMessageType.EXCEPTION:
4364 
      x = TApplicationException()
4365 
      x.read(self._iprot)
4366 
      self._iprot.readMessageEnd()
4367 
      raise x
4368 
    result = getAmazonSearchResultCount_result()
4369 
    result.read(self._iprot)
4370 
    self._iprot.readMessageEnd()
4371 
    if result.success is not None:
4372 
      return result.success
4373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4374 
 
4375 
  def getCountForAmazonlistedItems(self, ):
4376 
    self.send_getCountForAmazonlistedItems()
4377 
    return self.recv_getCountForAmazonlistedItems()
4378 
 
4379 
  def send_getCountForAmazonlistedItems(self, ):
4380 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4381 
    args = getCountForAmazonlistedItems_args()
4382 
    args.write(self._oprot)
4383 
    self._oprot.writeMessageEnd()
4384 
    self._oprot.trans.flush()
4385 
 
4386 
  def recv_getCountForAmazonlistedItems(self, ):
4387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4388 
    if mtype == TMessageType.EXCEPTION:
4389 
      x = TApplicationException()
4390 
      x.read(self._iprot)
4391 
      self._iprot.readMessageEnd()
4392 
      raise x
4393 
    result = getCountForAmazonlistedItems_result()
4394 
    result.read(self._iprot)
4395 
    self._iprot.readMessageEnd()
4396 
    if result.success is not None:
4397 
      return result.success
4398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4399 
 
7281 kshitij.so 4400 
  def getAmazonItemDetails(self, itemId):
4401 
    """
4402 
    Parameters:
4403 
     - itemId
4404 
    """
4405 
    self.send_getAmazonItemDetails(itemId)
4406 
    return self.recv_getAmazonItemDetails()
4407 
 
4408 
  def send_getAmazonItemDetails(self, itemId):
4409 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4410 
    args = getAmazonItemDetails_args()
4411 
    args.itemId = itemId
4412 
    args.write(self._oprot)
4413 
    self._oprot.writeMessageEnd()
4414 
    self._oprot.trans.flush()
4415 
 
4416 
  def recv_getAmazonItemDetails(self, ):
4417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4418 
    if mtype == TMessageType.EXCEPTION:
4419 
      x = TApplicationException()
4420 
      x.read(self._iprot)
4421 
      self._iprot.readMessageEnd()
4422 
      raise x
4423 
    result = getAmazonItemDetails_result()
4424 
    result.read(self._iprot)
4425 
    self._iprot.readMessageEnd()
4426 
    if result.success is not None:
4427 
      return result.success
4428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4429 
 
8168 kshitij.so 4430 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4431 
    """
4432 
    Parameters:
8168 kshitij.so 4433 
     - amazonlisted
7281 kshitij.so 4434 
    """
8168 kshitij.so 4435 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4436 
    self.recv_updateAmazonItemDetails()
4437 
 
8168 kshitij.so 4438 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4439 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4440 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4441 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4442 
    args.write(self._oprot)
4443 
    self._oprot.writeMessageEnd()
4444 
    self._oprot.trans.flush()
4445 
 
4446 
  def recv_updateAmazonItemDetails(self, ):
4447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4448 
    if mtype == TMessageType.EXCEPTION:
4449 
      x = TApplicationException()
4450 
      x.read(self._iprot)
4451 
      self._iprot.readMessageEnd()
4452 
      raise x
4453 
    result = updateAmazonItemDetails_result()
4454 
    result.read(self._iprot)
4455 
    self._iprot.readMessageEnd()
4456 
    return
4457 
 
4458 
  def addAmazonItem(self, amazonlisted):
4459 
    """
4460 
    Parameters:
4461 
     - amazonlisted
4462 
    """
4463 
    self.send_addAmazonItem(amazonlisted)
4464 
    self.recv_addAmazonItem()
4465 
 
4466 
  def send_addAmazonItem(self, amazonlisted):
4467 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4468 
    args = addAmazonItem_args()
4469 
    args.amazonlisted = amazonlisted
4470 
    args.write(self._oprot)
4471 
    self._oprot.writeMessageEnd()
4472 
    self._oprot.trans.flush()
4473 
 
4474 
  def recv_addAmazonItem(self, ):
4475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4476 
    if mtype == TMessageType.EXCEPTION:
4477 
      x = TApplicationException()
4478 
      x.read(self._iprot)
4479 
      self._iprot.readMessageEnd()
4480 
      raise x
4481 
    result = addAmazonItem_result()
4482 
    result.read(self._iprot)
4483 
    self._iprot.readMessageEnd()
4484 
    return
4485 
 
7291 vikram.rag 4486 
  def getAsinItems(self, ):
4487 
    self.send_getAsinItems()
4488 
    return self.recv_getAsinItems()
7281 kshitij.so 4489 
 
7291 vikram.rag 4490 
  def send_getAsinItems(self, ):
4491 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4492 
    args = getAsinItems_args()
4493 
    args.write(self._oprot)
4494 
    self._oprot.writeMessageEnd()
4495 
    self._oprot.trans.flush()
4496 
 
4497 
  def recv_getAsinItems(self, ):
4498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4499 
    if mtype == TMessageType.EXCEPTION:
4500 
      x = TApplicationException()
4501 
      x.read(self._iprot)
4502 
      self._iprot.readMessageEnd()
4503 
      raise x
4504 
    result = getAsinItems_result()
4505 
    result.read(self._iprot)
4506 
    self._iprot.readMessageEnd()
4507 
    if result.success is not None:
4508 
      return result.success
4509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4510 
 
4511 
  def getAllFbaListedItems(self, ):
4512 
    self.send_getAllFbaListedItems()
4513 
    return self.recv_getAllFbaListedItems()
4514 
 
4515 
  def send_getAllFbaListedItems(self, ):
4516 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4517 
    args = getAllFbaListedItems_args()
4518 
    args.write(self._oprot)
4519 
    self._oprot.writeMessageEnd()
4520 
    self._oprot.trans.flush()
4521 
 
4522 
  def recv_getAllFbaListedItems(self, ):
4523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4524 
    if mtype == TMessageType.EXCEPTION:
4525 
      x = TApplicationException()
4526 
      x.read(self._iprot)
4527 
      self._iprot.readMessageEnd()
4528 
      raise x
4529 
    result = getAllFbaListedItems_result()
4530 
    result.read(self._iprot)
4531 
    self._iprot.readMessageEnd()
4532 
    if result.success is not None:
4533 
      return result.success
4534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4535 
 
4536 
  def getAllNonFbaListedItems(self, ):
4537 
    self.send_getAllNonFbaListedItems()
4538 
    return self.recv_getAllNonFbaListedItems()
4539 
 
4540 
  def send_getAllNonFbaListedItems(self, ):
4541 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4542 
    args = getAllNonFbaListedItems_args()
4543 
    args.write(self._oprot)
4544 
    self._oprot.writeMessageEnd()
4545 
    self._oprot.trans.flush()
4546 
 
4547 
  def recv_getAllNonFbaListedItems(self, ):
4548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4549 
    if mtype == TMessageType.EXCEPTION:
4550 
      x = TApplicationException()
4551 
      x.read(self._iprot)
4552 
      self._iprot.readMessageEnd()
4553 
      raise x
4554 
    result = getAllNonFbaListedItems_result()
4555 
    result.read(self._iprot)
4556 
    self._iprot.readMessageEnd()
4557 
    if result.success is not None:
4558 
      return result.success
4559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4560 
 
7460 kshitij.so 4561 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4562 
    """
4563 
    Parameters:
4564 
     - itemId
4565 
     - holdInventory
4566 
     - defaultInventory
4567 
    """
4568 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4569 
    return self.recv_updateItemInventory()
7291 vikram.rag 4570 
 
7460 kshitij.so 4571 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4572 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4573 
    args = updateItemInventory_args()
4574 
    args.itemId = itemId
4575 
    args.holdInventory = holdInventory
4576 
    args.defaultInventory = defaultInventory
4577 
    args.write(self._oprot)
4578 
    self._oprot.writeMessageEnd()
4579 
    self._oprot.trans.flush()
4580 
 
4581 
  def recv_updateItemInventory(self, ):
4582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4583 
    if mtype == TMessageType.EXCEPTION:
4584 
      x = TApplicationException()
4585 
      x.read(self._iprot)
4586 
      self._iprot.readMessageEnd()
4587 
      raise x
4588 
    result = updateItemInventory_result()
4589 
    result.read(self._iprot)
4590 
    self._iprot.readMessageEnd()
4591 
    if result.success is not None:
4592 
      return result.success
4593 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4594 
 
7770 kshitij.so 4595 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4596 
    """
4597 
    Parameters:
4598 
     - type
4599 
     - sku
4600 
     - timestamp
4601 
    """
4602 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4603 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4604 
 
7770 kshitij.so 4605 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4606 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4607 
    args = updateTimestampForAmazonFeeds_args()
4608 
    args.type = type
4609 
    args.sku = sku
4610 
    args.timestamp = timestamp
4611 
    args.write(self._oprot)
4612 
    self._oprot.writeMessageEnd()
4613 
    self._oprot.trans.flush()
4614 
 
4615 
  def recv_updateTimestampForAmazonFeeds(self, ):
4616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4617 
    if mtype == TMessageType.EXCEPTION:
4618 
      x = TApplicationException()
4619 
      x.read(self._iprot)
4620 
      self._iprot.readMessageEnd()
4621 
      raise x
4622 
    result = updateTimestampForAmazonFeeds_result()
4623 
    result.read(self._iprot)
4624 
    self._iprot.readMessageEnd()
4625 
    if result.success is not None:
4626 
      return result.success
4627 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4628 
 
7897 amar.kumar 4629 
  def getAllParentCategories(self, ):
4630 
    self.send_getAllParentCategories()
4631 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4632 
 
7897 amar.kumar 4633 
  def send_getAllParentCategories(self, ):
4634 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4635 
    args = getAllParentCategories_args()
4636 
    args.write(self._oprot)
4637 
    self._oprot.writeMessageEnd()
4638 
    self._oprot.trans.flush()
4639 
 
4640 
  def recv_getAllParentCategories(self, ):
4641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4642 
    if mtype == TMessageType.EXCEPTION:
4643 
      x = TApplicationException()
4644 
      x.read(self._iprot)
4645 
      self._iprot.readMessageEnd()
4646 
      raise x
4647 
    result = getAllParentCategories_result()
4648 
    result.read(self._iprot)
4649 
    self._iprot.readMessageEnd()
4650 
    if result.success is not None:
4651 
      return result.success
4652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4653 
 
7977 kshitij.so 4654 
  def addPageViewEvent(self, pageViewEvents):
4655 
    """
4656 
    Parameters:
4657 
     - pageViewEvents
4658 
    """
4659 
    self.send_addPageViewEvent(pageViewEvents)
4660 
    self.recv_addPageViewEvent()
7897 amar.kumar 4661 
 
7977 kshitij.so 4662 
  def send_addPageViewEvent(self, pageViewEvents):
4663 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4664 
    args = addPageViewEvent_args()
4665 
    args.pageViewEvents = pageViewEvents
4666 
    args.write(self._oprot)
4667 
    self._oprot.writeMessageEnd()
4668 
    self._oprot.trans.flush()
4669 
 
4670 
  def recv_addPageViewEvent(self, ):
4671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4672 
    if mtype == TMessageType.EXCEPTION:
4673 
      x = TApplicationException()
4674 
      x.read(self._iprot)
4675 
      self._iprot.readMessageEnd()
4676 
      raise x
4677 
    result = addPageViewEvent_result()
4678 
    result.read(self._iprot)
4679 
    self._iprot.readMessageEnd()
4680 
    return
4681 
 
4682 
  def addCartEvent(self, cartEvents):
4683 
    """
4684 
    Parameters:
4685 
     - cartEvents
4686 
    """
4687 
    self.send_addCartEvent(cartEvents)
4688 
    self.recv_addCartEvent()
4689 
 
4690 
  def send_addCartEvent(self, cartEvents):
4691 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4692 
    args = addCartEvent_args()
4693 
    args.cartEvents = cartEvents
4694 
    args.write(self._oprot)
4695 
    self._oprot.writeMessageEnd()
4696 
    self._oprot.trans.flush()
4697 
 
4698 
  def recv_addCartEvent(self, ):
4699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4700 
    if mtype == TMessageType.EXCEPTION:
4701 
      x = TApplicationException()
4702 
      x.read(self._iprot)
4703 
      self._iprot.readMessageEnd()
4704 
      raise x
4705 
    result = addCartEvent_result()
4706 
    result.read(self._iprot)
4707 
    self._iprot.readMessageEnd()
4708 
    return
4709 
 
8182 amar.kumar 4710 
  def addEbayItem(self, ebayItem):
4711 
    """
4712 
    Parameters:
4713 
     - ebayItem
4714 
    """
4715 
    self.send_addEbayItem(ebayItem)
4716 
    self.recv_addEbayItem()
4717 
 
4718 
  def send_addEbayItem(self, ebayItem):
4719 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4720 
    args = addEbayItem_args()
4721 
    args.ebayItem = ebayItem
4722 
    args.write(self._oprot)
4723 
    self._oprot.writeMessageEnd()
4724 
    self._oprot.trans.flush()
4725 
 
4726 
  def recv_addEbayItem(self, ):
4727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4728 
    if mtype == TMessageType.EXCEPTION:
4729 
      x = TApplicationException()
4730 
      x.read(self._iprot)
4731 
      self._iprot.readMessageEnd()
4732 
      raise x
4733 
    result = addEbayItem_result()
4734 
    result.read(self._iprot)
4735 
    self._iprot.readMessageEnd()
4736 
    return
4737 
 
4738 
  def getEbayItem(self, listingId):
4739 
    """
4740 
    Parameters:
4741 
     - listingId
4742 
    """
4743 
    self.send_getEbayItem(listingId)
4744 
    return self.recv_getEbayItem()
4745 
 
4746 
  def send_getEbayItem(self, listingId):
4747 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4748 
    args = getEbayItem_args()
4749 
    args.listingId = listingId
4750 
    args.write(self._oprot)
4751 
    self._oprot.writeMessageEnd()
4752 
    self._oprot.trans.flush()
4753 
 
4754 
  def recv_getEbayItem(self, ):
4755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4756 
    if mtype == TMessageType.EXCEPTION:
4757 
      x = TApplicationException()
4758 
      x.read(self._iprot)
4759 
      self._iprot.readMessageEnd()
4760 
      raise x
4761 
    result = getEbayItem_result()
4762 
    result.read(self._iprot)
4763 
    self._iprot.readMessageEnd()
4764 
    if result.success is not None:
4765 
      return result.success
4766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4767 
 
4768 
  def updateEbayItem(self, ebayItem):
4769 
    """
4770 
    Parameters:
4771 
     - ebayItem
4772 
    """
4773 
    self.send_updateEbayItem(ebayItem)
4774 
    self.recv_updateEbayItem()
4775 
 
4776 
  def send_updateEbayItem(self, ebayItem):
4777 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4778 
    args = updateEbayItem_args()
4779 
    args.ebayItem = ebayItem
4780 
    args.write(self._oprot)
4781 
    self._oprot.writeMessageEnd()
4782 
    self._oprot.trans.flush()
4783 
 
4784 
  def recv_updateEbayItem(self, ):
4785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4786 
    if mtype == TMessageType.EXCEPTION:
4787 
      x = TApplicationException()
4788 
      x.read(self._iprot)
4789 
      self._iprot.readMessageEnd()
4790 
      raise x
4791 
    result = updateEbayItem_result()
4792 
    result.read(self._iprot)
4793 
    self._iprot.readMessageEnd()
4794 
    return
4795 
 
8139 kshitij.so 4796 
  def getAmazonListedItems(self, offset, limit):
4797 
    """
4798 
    Parameters:
4799 
     - offset
4800 
     - limit
4801 
    """
4802 
    self.send_getAmazonListedItems(offset, limit)
4803 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4804 
 
8139 kshitij.so 4805 
  def send_getAmazonListedItems(self, offset, limit):
4806 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4807 
    args = getAmazonListedItems_args()
4808 
    args.offset = offset
4809 
    args.limit = limit
4810 
    args.write(self._oprot)
4811 
    self._oprot.writeMessageEnd()
4812 
    self._oprot.trans.flush()
4813 
 
4814 
  def recv_getAmazonListedItems(self, ):
4815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4816 
    if mtype == TMessageType.EXCEPTION:
4817 
      x = TApplicationException()
4818 
      x.read(self._iprot)
4819 
      self._iprot.readMessageEnd()
4820 
      raise x
4821 
    result = getAmazonListedItems_result()
4822 
    result.read(self._iprot)
4823 
    self._iprot.readMessageEnd()
4824 
    if result.success is not None:
4825 
      return result.success
4826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4827 
 
8168 kshitij.so 4828 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4829 
    """
4830 
    Parameters:
4831 
     - amazonlisted
4832 
    """
4833 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4834 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4835 
 
8168 kshitij.so 4836 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4837 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4838 
    args = updateAmazonAttributesInBulk_args()
4839 
    args.amazonlisted = amazonlisted
4840 
    args.write(self._oprot)
4841 
    self._oprot.writeMessageEnd()
4842 
    self._oprot.trans.flush()
4843 
 
4844 
  def recv_updateAmazonAttributesInBulk(self, ):
4845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4846 
    if mtype == TMessageType.EXCEPTION:
4847 
      x = TApplicationException()
4848 
      x.read(self._iprot)
4849 
      self._iprot.readMessageEnd()
4850 
      raise x
4851 
    result = updateAmazonAttributesInBulk_result()
4852 
    result.read(self._iprot)
4853 
    self._iprot.readMessageEnd()
4854 
    if result.success is not None:
4855 
      return result.success
4856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4857 
 
8379 vikram.rag 4858 
  def getAllItemstoListOnFba(self, ):
4859 
    self.send_getAllItemstoListOnFba()
4860 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4861 
 
8379 vikram.rag 4862 
  def send_getAllItemstoListOnFba(self, ):
4863 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4864 
    args = getAllItemstoListOnFba_args()
4865 
    args.write(self._oprot)
4866 
    self._oprot.writeMessageEnd()
4867 
    self._oprot.trans.flush()
4868 
 
4869 
  def recv_getAllItemstoListOnFba(self, ):
4870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4871 
    if mtype == TMessageType.EXCEPTION:
4872 
      x = TApplicationException()
4873 
      x.read(self._iprot)
4874 
      self._iprot.readMessageEnd()
4875 
      raise x
4876 
    result = getAllItemstoListOnFba_result()
4877 
    result.read(self._iprot)
4878 
    self._iprot.readMessageEnd()
4879 
    if result.success is not None:
4880 
      return result.success
4881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4882 
 
4883 
  def getAllItemstoListOnNonFba(self, ):
4884 
    self.send_getAllItemstoListOnNonFba()
4885 
    return self.recv_getAllItemstoListOnNonFba()
4886 
 
4887 
  def send_getAllItemstoListOnNonFba(self, ):
4888 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4889 
    args = getAllItemstoListOnNonFba_args()
4890 
    args.write(self._oprot)
4891 
    self._oprot.writeMessageEnd()
4892 
    self._oprot.trans.flush()
4893 
 
4894 
  def recv_getAllItemstoListOnNonFba(self, ):
4895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4896 
    if mtype == TMessageType.EXCEPTION:
4897 
      x = TApplicationException()
4898 
      x.read(self._iprot)
4899 
      self._iprot.readMessageEnd()
4900 
      raise x
4901 
    result = getAllItemstoListOnNonFba_result()
4902 
    result.read(self._iprot)
4903 
    self._iprot.readMessageEnd()
4904 
    if result.success is not None:
4905 
      return result.success
4906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4907 
 
8619 kshitij.so 4908 
  def updateAsin(self, item):
4909 
    """
4910 
    Parameters:
4911 
     - item
4912 
    """
4913 
    self.send_updateAsin(item)
4914 
    self.recv_updateAsin()
8616 vikram.rag 4915 
 
8619 kshitij.so 4916 
  def send_updateAsin(self, item):
4917 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4918 
    args = updateAsin_args()
4919 
    args.item = item
4920 
    args.write(self._oprot)
4921 
    self._oprot.writeMessageEnd()
4922 
    self._oprot.trans.flush()
4923 
 
4924 
  def recv_updateAsin(self, ):
4925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4926 
    if mtype == TMessageType.EXCEPTION:
4927 
      x = TApplicationException()
4928 
      x.read(self._iprot)
4929 
      self._iprot.readMessageEnd()
4930 
      raise x
4931 
    result = updateAsin_result()
4932 
    result.read(self._iprot)
4933 
    self._iprot.readMessageEnd()
4934 
    return
4935 
 
8739 vikram.rag 4936 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4937 
    """
4938 
    Parameters:
4939 
     - snapdealitem
4940 
    """
4941 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4942 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4943 
 
8739 vikram.rag 4944 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4945 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4946 
    args = addOrUpdateSnapdealItem_args()
4947 
    args.snapdealitem = snapdealitem
4948 
    args.write(self._oprot)
4949 
    self._oprot.writeMessageEnd()
4950 
    self._oprot.trans.flush()
4951 
 
4952 
  def recv_addOrUpdateSnapdealItem(self, ):
4953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4954 
    if mtype == TMessageType.EXCEPTION:
4955 
      x = TApplicationException()
4956 
      x.read(self._iprot)
4957 
      self._iprot.readMessageEnd()
4958 
      raise x
4959 
    result = addOrUpdateSnapdealItem_result()
4960 
    result.read(self._iprot)
4961 
    self._iprot.readMessageEnd()
4962 
    if result.success is not None:
4963 
      return result.success
4964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4965 
 
4966 
  def getSnapdealItem(self, item_id):
4967 
    """
4968 
    Parameters:
4969 
     - item_id
4970 
    """
4971 
    self.send_getSnapdealItem(item_id)
4972 
    return self.recv_getSnapdealItem()
4973 
 
4974 
  def send_getSnapdealItem(self, item_id):
4975 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4976 
    args = getSnapdealItem_args()
4977 
    args.item_id = item_id
4978 
    args.write(self._oprot)
4979 
    self._oprot.writeMessageEnd()
4980 
    self._oprot.trans.flush()
4981 
 
4982 
  def recv_getSnapdealItem(self, ):
4983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4984 
    if mtype == TMessageType.EXCEPTION:
4985 
      x = TApplicationException()
4986 
      x.read(self._iprot)
4987 
      self._iprot.readMessageEnd()
4988 
      raise x
4989 
    result = getSnapdealItem_result()
4990 
    result.read(self._iprot)
4991 
    self._iprot.readMessageEnd()
4992 
    if result.success is not None:
4993 
      return result.success
4994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4995 
 
9242 kshitij.so 4996 
  def getSnapdealItemDetails(self, item_id):
4997 
    """
4998 
    Parameters:
4999 
     - item_id
5000 
    """
5001 
    self.send_getSnapdealItemDetails(item_id)
5002 
    return self.recv_getSnapdealItemDetails()
5003 
 
5004 
  def send_getSnapdealItemDetails(self, item_id):
5005 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
5006 
    args = getSnapdealItemDetails_args()
5007 
    args.item_id = item_id
5008 
    args.write(self._oprot)
5009 
    self._oprot.writeMessageEnd()
5010 
    self._oprot.trans.flush()
5011 
 
5012 
  def recv_getSnapdealItemDetails(self, ):
5013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5014 
    if mtype == TMessageType.EXCEPTION:
5015 
      x = TApplicationException()
5016 
      x.read(self._iprot)
5017 
      self._iprot.readMessageEnd()
5018 
      raise x
5019 
    result = getSnapdealItemDetails_result()
5020 
    result.read(self._iprot)
5021 
    self._iprot.readMessageEnd()
5022 
    if result.success is not None:
5023 
      return result.success
5024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
5025 
 
8739 vikram.rag 5026 
  def getAllSnapdealItems(self, ):
5027 
    self.send_getAllSnapdealItems()
5028 
    return self.recv_getAllSnapdealItems()
5029 
 
5030 
  def send_getAllSnapdealItems(self, ):
5031 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
5032 
    args = getAllSnapdealItems_args()
5033 
    args.write(self._oprot)
5034 
    self._oprot.writeMessageEnd()
5035 
    self._oprot.trans.flush()
5036 
 
5037 
  def recv_getAllSnapdealItems(self, ):
5038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5039 
    if mtype == TMessageType.EXCEPTION:
5040 
      x = TApplicationException()
5041 
      x.read(self._iprot)
5042 
      self._iprot.readMessageEnd()
5043 
      raise x
5044 
    result = getAllSnapdealItems_result()
5045 
    result.read(self._iprot)
5046 
    self._iprot.readMessageEnd()
5047 
    if result.success is not None:
5048 
      return result.success
5049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
5050 
 
9242 kshitij.so 5051 
  def getSnapdealItems(self, offset, limit):
5052 
    """
5053 
    Parameters:
5054 
     - offset
5055 
     - limit
5056 
    """
5057 
    self.send_getSnapdealItems(offset, limit)
5058 
    return self.recv_getSnapdealItems()
8739 vikram.rag 5059 
 
9242 kshitij.so 5060 
  def send_getSnapdealItems(self, offset, limit):
5061 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
5062 
    args = getSnapdealItems_args()
5063 
    args.offset = offset
5064 
    args.limit = limit
5065 
    args.write(self._oprot)
5066 
    self._oprot.writeMessageEnd()
5067 
    self._oprot.trans.flush()
5068 
 
5069 
  def recv_getSnapdealItems(self, ):
5070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5071 
    if mtype == TMessageType.EXCEPTION:
5072 
      x = TApplicationException()
5073 
      x.read(self._iprot)
5074 
      self._iprot.readMessageEnd()
5075 
      raise x
5076 
    result = getSnapdealItems_result()
5077 
    result.read(self._iprot)
5078 
    self._iprot.readMessageEnd()
5079 
    if result.success is not None:
5080 
      return result.success
5081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
5082 
 
5083 
  def searchSnapdealItems(self, searchTerm, offset, limit):
5084 
    """
5085 
    Parameters:
5086 
     - searchTerm
5087 
     - offset
5088 
     - limit
5089 
    """
5090 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
5091 
    return self.recv_searchSnapdealItems()
5092 
 
5093 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
5094 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
5095 
    args = searchSnapdealItems_args()
5096 
    args.searchTerm = searchTerm
5097 
    args.offset = offset
5098 
    args.limit = limit
5099 
    args.write(self._oprot)
5100 
    self._oprot.writeMessageEnd()
5101 
    self._oprot.trans.flush()
5102 
 
5103 
  def recv_searchSnapdealItems(self, ):
5104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5105 
    if mtype == TMessageType.EXCEPTION:
5106 
      x = TApplicationException()
5107 
      x.read(self._iprot)
5108 
      self._iprot.readMessageEnd()
5109 
      raise x
5110 
    result = searchSnapdealItems_result()
5111 
    result.read(self._iprot)
5112 
    self._iprot.readMessageEnd()
5113 
    if result.success is not None:
5114 
      return result.success
5115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
5116 
 
5117 
  def getCountForSnapdealItems(self, ):
5118 
    self.send_getCountForSnapdealItems()
5119 
    return self.recv_getCountForSnapdealItems()
5120 
 
5121 
  def send_getCountForSnapdealItems(self, ):
5122 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
5123 
    args = getCountForSnapdealItems_args()
5124 
    args.write(self._oprot)
5125 
    self._oprot.writeMessageEnd()
5126 
    self._oprot.trans.flush()
5127 
 
5128 
  def recv_getCountForSnapdealItems(self, ):
5129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5130 
    if mtype == TMessageType.EXCEPTION:
5131 
      x = TApplicationException()
5132 
      x.read(self._iprot)
5133 
      self._iprot.readMessageEnd()
5134 
      raise x
5135 
    result = getCountForSnapdealItems_result()
5136 
    result.read(self._iprot)
5137 
    self._iprot.readMessageEnd()
5138 
    if result.success is not None:
5139 
      return result.success
5140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5141 
 
5142 
  def getSnapdealSearchResultCount(self, searchTerm):
5143 
    """
5144 
    Parameters:
5145 
     - searchTerm
5146 
    """
5147 
    self.send_getSnapdealSearchResultCount(searchTerm)
5148 
    return self.recv_getSnapdealSearchResultCount()
5149 
 
5150 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5151 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5152 
    args = getSnapdealSearchResultCount_args()
5153 
    args.searchTerm = searchTerm
5154 
    args.write(self._oprot)
5155 
    self._oprot.writeMessageEnd()
5156 
    self._oprot.trans.flush()
5157 
 
5158 
  def recv_getSnapdealSearchResultCount(self, ):
5159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5160 
    if mtype == TMessageType.EXCEPTION:
5161 
      x = TApplicationException()
5162 
      x.read(self._iprot)
5163 
      self._iprot.readMessageEnd()
5164 
      raise x
5165 
    result = getSnapdealSearchResultCount_result()
5166 
    result.read(self._iprot)
5167 
    self._iprot.readMessageEnd()
5168 
    if result.success is not None:
5169 
      return result.success
5170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5171 
 
9299 kshitij.so 5172 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5173 
    """
5174 
    Parameters:
5175 
     - itemId
5176 
     - insurerType
5177 
    """
5178 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5179 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5180 
 
9299 kshitij.so 5181 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5182 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5183 
    args = getPrefferedInsurerForItem_args()
5184 
    args.itemId = itemId
5185 
    args.insurerType = insurerType
5186 
    args.write(self._oprot)
5187 
    self._oprot.writeMessageEnd()
5188 
    self._oprot.trans.flush()
5189 
 
5190 
  def recv_getPrefferedInsurerForItem(self, ):
5191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5192 
    if mtype == TMessageType.EXCEPTION:
5193 
      x = TApplicationException()
5194 
      x.read(self._iprot)
5195 
      self._iprot.readMessageEnd()
5196 
      raise x
5197 
    result = getPrefferedInsurerForItem_result()
5198 
    result.read(self._iprot)
5199 
    self._iprot.readMessageEnd()
5200 
    if result.success is not None:
5201 
      return result.success
5202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5203 
 
9456 vikram.rag 5204 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5205 
    """
5206 
    Parameters:
5207 
     - skuAtSnapdeal
5208 
    """
5209 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5210 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5211 
 
9456 vikram.rag 5212 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5213 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5214 
    args = getSnapdealItembySkuAtSnapdeal_args()
5215 
    args.skuAtSnapdeal = skuAtSnapdeal
5216 
    args.write(self._oprot)
5217 
    self._oprot.writeMessageEnd()
5218 
    self._oprot.trans.flush()
5219 
 
5220 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5222 
    if mtype == TMessageType.EXCEPTION:
5223 
      x = TApplicationException()
5224 
      x.read(self._iprot)
5225 
      self._iprot.readMessageEnd()
5226 
      raise x
5227 
    result = getSnapdealItembySkuAtSnapdeal_result()
5228 
    result.read(self._iprot)
5229 
    self._iprot.readMessageEnd()
5230 
    if result.success is not None:
5231 
      return result.success
5232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5233 
 
9621 manish.sha 5234 
  def getProductFeedSubmit(self, catalogItemId):
5235 
    """
5236 
    Parameters:
5237 
     - catalogItemId
5238 
    """
5239 
    self.send_getProductFeedSubmit(catalogItemId)
5240 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5241 
 
9621 manish.sha 5242 
  def send_getProductFeedSubmit(self, catalogItemId):
5243 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5244 
    args = getProductFeedSubmit_args()
5245 
    args.catalogItemId = catalogItemId
5246 
    args.write(self._oprot)
5247 
    self._oprot.writeMessageEnd()
5248 
    self._oprot.trans.flush()
5249 
 
5250 
  def recv_getProductFeedSubmit(self, ):
5251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5252 
    if mtype == TMessageType.EXCEPTION:
5253 
      x = TApplicationException()
5254 
      x.read(self._iprot)
5255 
      self._iprot.readMessageEnd()
5256 
      raise x
5257 
    result = getProductFeedSubmit_result()
5258 
    result.read(self._iprot)
5259 
    self._iprot.readMessageEnd()
5260 
    if result.success is not None:
5261 
      return result.success
5262 
    if result.cex is not None:
5263 
      raise result.cex
5264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5265 
 
5266 
  def addProductFeedSubmit(self, productFeedSubmit):
5267 
    """
5268 
    Parameters:
5269 
     - productFeedSubmit
5270 
    """
5271 
    self.send_addProductFeedSubmit(productFeedSubmit)
5272 
    return self.recv_addProductFeedSubmit()
5273 
 
5274 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5275 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5276 
    args = addProductFeedSubmit_args()
5277 
    args.productFeedSubmit = productFeedSubmit
5278 
    args.write(self._oprot)
5279 
    self._oprot.writeMessageEnd()
5280 
    self._oprot.trans.flush()
5281 
 
5282 
  def recv_addProductFeedSubmit(self, ):
5283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5284 
    if mtype == TMessageType.EXCEPTION:
5285 
      x = TApplicationException()
5286 
      x.read(self._iprot)
5287 
      self._iprot.readMessageEnd()
5288 
      raise x
5289 
    result = addProductFeedSubmit_result()
5290 
    result.read(self._iprot)
5291 
    self._iprot.readMessageEnd()
5292 
    if result.success is not None:
5293 
      return result.success
5294 
    if result.cex is not None:
5295 
      raise result.cex
5296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5297 
 
5298 
  def updateProductFeedSubmit(self, productFeedSubmit):
5299 
    """
5300 
    Parameters:
5301 
     - productFeedSubmit
5302 
    """
5303 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5304 
    return self.recv_updateProductFeedSubmit()
5305 
 
5306 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5307 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5308 
    args = updateProductFeedSubmit_args()
5309 
    args.productFeedSubmit = productFeedSubmit
5310 
    args.write(self._oprot)
5311 
    self._oprot.writeMessageEnd()
5312 
    self._oprot.trans.flush()
5313 
 
5314 
  def recv_updateProductFeedSubmit(self, ):
5315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5316 
    if mtype == TMessageType.EXCEPTION:
5317 
      x = TApplicationException()
5318 
      x.read(self._iprot)
5319 
      self._iprot.readMessageEnd()
5320 
      raise x
5321 
    result = updateProductFeedSubmit_result()
5322 
    result.read(self._iprot)
5323 
    self._iprot.readMessageEnd()
5324 
    if result.success is not None:
5325 
      return result.success
5326 
    if result.cex is not None:
5327 
      raise result.cex
5328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5329 
 
5330 
  def deleteProductFeedSubmit(self, catalogItemId):
5331 
    """
5332 
    Parameters:
5333 
     - catalogItemId
5334 
    """
5335 
    self.send_deleteProductFeedSubmit(catalogItemId)
5336 
    return self.recv_deleteProductFeedSubmit()
5337 
 
5338 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5339 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5340 
    args = deleteProductFeedSubmit_args()
5341 
    args.catalogItemId = catalogItemId
5342 
    args.write(self._oprot)
5343 
    self._oprot.writeMessageEnd()
5344 
    self._oprot.trans.flush()
5345 
 
5346 
  def recv_deleteProductFeedSubmit(self, ):
5347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5348 
    if mtype == TMessageType.EXCEPTION:
5349 
      x = TApplicationException()
5350 
      x.read(self._iprot)
5351 
      self._iprot.readMessageEnd()
5352 
      raise x
5353 
    result = deleteProductFeedSubmit_result()
5354 
    result.read(self._iprot)
5355 
    self._iprot.readMessageEnd()
5356 
    if result.success is not None:
5357 
      return result.success
5358 
    if result.cex is not None:
5359 
      raise result.cex
5360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5361 
 
5362 
  def getAllProductFeedSubmit(self, ):
5363 
    self.send_getAllProductFeedSubmit()
5364 
    return self.recv_getAllProductFeedSubmit()
5365 
 
5366 
  def send_getAllProductFeedSubmit(self, ):
5367 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5368 
    args = getAllProductFeedSubmit_args()
5369 
    args.write(self._oprot)
5370 
    self._oprot.writeMessageEnd()
5371 
    self._oprot.trans.flush()
5372 
 
5373 
  def recv_getAllProductFeedSubmit(self, ):
5374 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5375 
    if mtype == TMessageType.EXCEPTION:
5376 
      x = TApplicationException()
5377 
      x.read(self._iprot)
5378 
      self._iprot.readMessageEnd()
5379 
      raise x
5380 
    result = getAllProductFeedSubmit_result()
5381 
    result.read(self._iprot)
5382 
    self._iprot.readMessageEnd()
5383 
    if result.success is not None:
5384 
      return result.success
5385 
    if result.cex is not None:
5386 
      raise result.cex
5387 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5388 
 
9724 kshitij.so 5389 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5390 
    """
5391 
    Parameters:
5392 
     - itemId
5393 
     - sourceId
5394 
    """
5395 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5396 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5397 
 
9724 kshitij.so 5398 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5399 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5400 
    args = getMarketplacedetailsForItem_args()
5401 
    args.itemId = itemId
5402 
    args.sourceId = sourceId
5403 
    args.write(self._oprot)
5404 
    self._oprot.writeMessageEnd()
5405 
    self._oprot.trans.flush()
5406 
 
5407 
  def recv_getMarketplacedetailsForItem(self, ):
5408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5409 
    if mtype == TMessageType.EXCEPTION:
5410 
      x = TApplicationException()
5411 
      x.read(self._iprot)
5412 
      self._iprot.readMessageEnd()
5413 
      raise x
5414 
    result = getMarketplacedetailsForItem_result()
5415 
    result.read(self._iprot)
5416 
    self._iprot.readMessageEnd()
5417 
    if result.success is not None:
5418 
      return result.success
5419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5420 
 
5421 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5422 
    """
5423 
    Parameters:
5424 
     - marketPlaceItem
5425 
    """
5426 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5427 
    return self.recv_updateMarketplaceAttributesForItem()
5428 
 
5429 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5430 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5431 
    args = updateMarketplaceAttributesForItem_args()
5432 
    args.marketPlaceItem = marketPlaceItem
5433 
    args.write(self._oprot)
5434 
    self._oprot.writeMessageEnd()
5435 
    self._oprot.trans.flush()
5436 
 
5437 
  def recv_updateMarketplaceAttributesForItem(self, ):
5438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5439 
    if mtype == TMessageType.EXCEPTION:
5440 
      x = TApplicationException()
5441 
      x.read(self._iprot)
5442 
      self._iprot.readMessageEnd()
5443 
      raise x
5444 
    result = updateMarketplaceAttributesForItem_result()
5445 
    result.read(self._iprot)
5446 
    self._iprot.readMessageEnd()
5447 
    if result.success is not None:
5448 
      return result.success
5449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5450 
 
9779 kshitij.so 5451 
  def getCostingForMarketplace(self, source, item_id):
5452 
    """
5453 
    Parameters:
5454 
     - source
5455 
     - item_id
5456 
    """
5457 
    self.send_getCostingForMarketplace(source, item_id)
5458 
    return self.recv_getCostingForMarketplace()
5459 
 
5460 
  def send_getCostingForMarketplace(self, source, item_id):
5461 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5462 
    args = getCostingForMarketplace_args()
5463 
    args.source = source
5464 
    args.item_id = item_id
5465 
    args.write(self._oprot)
5466 
    self._oprot.writeMessageEnd()
5467 
    self._oprot.trans.flush()
5468 
 
5469 
  def recv_getCostingForMarketplace(self, ):
5470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5471 
    if mtype == TMessageType.EXCEPTION:
5472 
      x = TApplicationException()
5473 
      x.read(self._iprot)
5474 
      self._iprot.readMessageEnd()
5475 
      raise x
5476 
    result = getCostingForMarketplace_result()
5477 
    result.read(self._iprot)
5478 
    self._iprot.readMessageEnd()
5479 
    if result.success is not None:
5480 
      return result.success
5481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5482 
 
9776 vikram.rag 5483 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5484 
    """
5485 
    Parameters:
5486 
     - source
5487 
    """
5488 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5489 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5490 
 
9776 vikram.rag 5491 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5492 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5493 
    args = getMarketPlaceItemsForPriceUpdate_args()
5494 
    args.source = source
5495 
    args.write(self._oprot)
5496 
    self._oprot.writeMessageEnd()
5497 
    self._oprot.trans.flush()
5498 
 
5499 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5501 
    if mtype == TMessageType.EXCEPTION:
5502 
      x = TApplicationException()
5503 
      x.read(self._iprot)
5504 
      self._iprot.readMessageEnd()
5505 
      raise x
5506 
    result = getMarketPlaceItemsForPriceUpdate_result()
5507 
    result.read(self._iprot)
5508 
    self._iprot.readMessageEnd()
5509 
    if result.success is not None:
5510 
      return result.success
5511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5512 
 
9816 kshitij.so 5513 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5514 
    """
5515 
    Parameters:
5516 
     - skulist
5517 
     - timestamp
9816 kshitij.so 5518 
     - source
9776 vikram.rag 5519 
    """
9816 kshitij.so 5520 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5521 
    self.recv_updateMarketPlacePriceUpdateStatus()
5522 
 
9816 kshitij.so 5523 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5524 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5525 
    args = updateMarketPlacePriceUpdateStatus_args()
5526 
    args.skulist = skulist
5527 
    args.timestamp = timestamp
9816 kshitij.so 5528 
    args.source = source
9776 vikram.rag 5529 
    args.write(self._oprot)
5530 
    self._oprot.writeMessageEnd()
5531 
    self._oprot.trans.flush()
5532 
 
5533 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5535 
    if mtype == TMessageType.EXCEPTION:
5536 
      x = TApplicationException()
5537 
      x.read(self._iprot)
5538 
      self._iprot.readMessageEnd()
5539 
      raise x
5540 
    result = updateMarketPlacePriceUpdateStatus_result()
5541 
    result.read(self._iprot)
5542 
    self._iprot.readMessageEnd()
5543 
    return
5544 
 
9861 rajveer 5545 
  def updateItemHoldInventory(self, itemHoldMap):
5546 
    """
5547 
    Parameters:
5548 
     - itemHoldMap
5549 
    """
5550 
    self.send_updateItemHoldInventory(itemHoldMap)
5551 
    self.recv_updateItemHoldInventory()
9776 vikram.rag 5552 
 
9861 rajveer 5553 
  def send_updateItemHoldInventory(self, itemHoldMap):
5554 
    self._oprot.writeMessageBegin('updateItemHoldInventory', TMessageType.CALL, self._seqid)
5555 
    args = updateItemHoldInventory_args()
5556 
    args.itemHoldMap = itemHoldMap
5557 
    args.write(self._oprot)
5558 
    self._oprot.writeMessageEnd()
5559 
    self._oprot.trans.flush()
5560 
 
5561 
  def recv_updateItemHoldInventory(self, ):
5562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5563 
    if mtype == TMessageType.EXCEPTION:
5564 
      x = TApplicationException()
5565 
      x.read(self._iprot)
5566 
      self._iprot.readMessageEnd()
5567 
      raise x
5568 
    result = updateItemHoldInventory_result()
5569 
    result.read(self._iprot)
5570 
    self._iprot.readMessageEnd()
5571 
    return
5572 
 
9895 vikram.rag 5573 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5574 
    """
5575 
    Parameters:
5576 
     - item_id
5577 
     - vendor_id
5578 
     - nlc
5579 
    """
5580 
    self.send_updateNlcAtMarketplaces(item_id, vendor_id, nlc)
5581 
    self.recv_updateNlcAtMarketplaces()
9861 rajveer 5582 
 
9895 vikram.rag 5583 
  def send_updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5584 
    self._oprot.writeMessageBegin('updateNlcAtMarketplaces', TMessageType.CALL, self._seqid)
5585 
    args = updateNlcAtMarketplaces_args()
5586 
    args.item_id = item_id
5587 
    args.vendor_id = vendor_id
5588 
    args.nlc = nlc
5589 
    args.write(self._oprot)
5590 
    self._oprot.writeMessageEnd()
5591 
    self._oprot.trans.flush()
5592 
 
5593 
  def recv_updateNlcAtMarketplaces(self, ):
5594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5595 
    if mtype == TMessageType.EXCEPTION:
5596 
      x = TApplicationException()
5597 
      x.read(self._iprot)
5598 
      self._iprot.readMessageEnd()
5599 
      raise x
5600 
    result = updateNlcAtMarketplaces_result()
5601 
    result.read(self._iprot)
5602 
    self._iprot.readMessageEnd()
5603 
    return
5604 
 
9945 vikram.rag 5605 
  def getAllFlipkartItems(self, ):
5606 
    self.send_getAllFlipkartItems()
5607 
    return self.recv_getAllFlipkartItems()
9895 vikram.rag 5608 
 
9945 vikram.rag 5609 
  def send_getAllFlipkartItems(self, ):
5610 
    self._oprot.writeMessageBegin('getAllFlipkartItems', TMessageType.CALL, self._seqid)
5611 
    args = getAllFlipkartItems_args()
5612 
    args.write(self._oprot)
5613 
    self._oprot.writeMessageEnd()
5614 
    self._oprot.trans.flush()
5615 
 
5616 
  def recv_getAllFlipkartItems(self, ):
5617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5618 
    if mtype == TMessageType.EXCEPTION:
5619 
      x = TApplicationException()
5620 
      x.read(self._iprot)
5621 
      self._iprot.readMessageEnd()
5622 
      raise x
5623 
    result = getAllFlipkartItems_result()
5624 
    result.read(self._iprot)
5625 
    self._iprot.readMessageEnd()
5626 
    if result.success is not None:
5627 
      return result.success
5628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartItems failed: unknown result");
5629 
 
10097 kshitij.so 5630 
  def addOrUpdateFlipkartItem(self, flipkartitem):
5631 
    """
5632 
    Parameters:
5633 
     - flipkartitem
5634 
    """
5635 
    self.send_addOrUpdateFlipkartItem(flipkartitem)
5636 
    return self.recv_addOrUpdateFlipkartItem()
9945 vikram.rag 5637 
 
10097 kshitij.so 5638 
  def send_addOrUpdateFlipkartItem(self, flipkartitem):
5639 
    self._oprot.writeMessageBegin('addOrUpdateFlipkartItem', TMessageType.CALL, self._seqid)
5640 
    args = addOrUpdateFlipkartItem_args()
5641 
    args.flipkartitem = flipkartitem
5642 
    args.write(self._oprot)
5643 
    self._oprot.writeMessageEnd()
5644 
    self._oprot.trans.flush()
5645 
 
5646 
  def recv_addOrUpdateFlipkartItem(self, ):
5647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5648 
    if mtype == TMessageType.EXCEPTION:
5649 
      x = TApplicationException()
5650 
      x.read(self._iprot)
5651 
      self._iprot.readMessageEnd()
5652 
      raise x
5653 
    result = addOrUpdateFlipkartItem_result()
5654 
    result.read(self._iprot)
5655 
    self._iprot.readMessageEnd()
5656 
    if result.success is not None:
5657 
      return result.success
5658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateFlipkartItem failed: unknown result");
5659 
 
5660 
  def getFlipkartItem(self, item_id):
5661 
    """
5662 
    Parameters:
5663 
     - item_id
5664 
    """
5665 
    self.send_getFlipkartItem(item_id)
5666 
    return self.recv_getFlipkartItem()
5667 
 
5668 
  def send_getFlipkartItem(self, item_id):
5669 
    self._oprot.writeMessageBegin('getFlipkartItem', TMessageType.CALL, self._seqid)
5670 
    args = getFlipkartItem_args()
5671 
    args.item_id = item_id
5672 
    args.write(self._oprot)
5673 
    self._oprot.writeMessageEnd()
5674 
    self._oprot.trans.flush()
5675 
 
5676 
  def recv_getFlipkartItem(self, ):
5677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5678 
    if mtype == TMessageType.EXCEPTION:
5679 
      x = TApplicationException()
5680 
      x.read(self._iprot)
5681 
      self._iprot.readMessageEnd()
5682 
      raise x
5683 
    result = getFlipkartItem_result()
5684 
    result.read(self._iprot)
5685 
    self._iprot.readMessageEnd()
5686 
    if result.success is not None:
5687 
      return result.success
5688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItem failed: unknown result");
5689 
 
5690 
  def getFlipkartItemDetails(self, item_id):
5691 
    """
5692 
    Parameters:
5693 
     - item_id
5694 
    """
5695 
    self.send_getFlipkartItemDetails(item_id)
5696 
    return self.recv_getFlipkartItemDetails()
5697 
 
5698 
  def send_getFlipkartItemDetails(self, item_id):
5699 
    self._oprot.writeMessageBegin('getFlipkartItemDetails', TMessageType.CALL, self._seqid)
5700 
    args = getFlipkartItemDetails_args()
5701 
    args.item_id = item_id
5702 
    args.write(self._oprot)
5703 
    self._oprot.writeMessageEnd()
5704 
    self._oprot.trans.flush()
5705 
 
5706 
  def recv_getFlipkartItemDetails(self, ):
5707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5708 
    if mtype == TMessageType.EXCEPTION:
5709 
      x = TApplicationException()
5710 
      x.read(self._iprot)
5711 
      self._iprot.readMessageEnd()
5712 
      raise x
5713 
    result = getFlipkartItemDetails_result()
5714 
    result.read(self._iprot)
5715 
    self._iprot.readMessageEnd()
5716 
    if result.success is not None:
5717 
      return result.success
5718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemDetails failed: unknown result");
5719 
 
5720 
  def getFlipkartItems(self, offset, limit):
5721 
    """
5722 
    Parameters:
5723 
     - offset
5724 
     - limit
5725 
    """
5726 
    self.send_getFlipkartItems(offset, limit)
5727 
    return self.recv_getFlipkartItems()
5728 
 
5729 
  def send_getFlipkartItems(self, offset, limit):
5730 
    self._oprot.writeMessageBegin('getFlipkartItems', TMessageType.CALL, self._seqid)
5731 
    args = getFlipkartItems_args()
5732 
    args.offset = offset
5733 
    args.limit = limit
5734 
    args.write(self._oprot)
5735 
    self._oprot.writeMessageEnd()
5736 
    self._oprot.trans.flush()
5737 
 
5738 
  def recv_getFlipkartItems(self, ):
5739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5740 
    if mtype == TMessageType.EXCEPTION:
5741 
      x = TApplicationException()
5742 
      x.read(self._iprot)
5743 
      self._iprot.readMessageEnd()
5744 
      raise x
5745 
    result = getFlipkartItems_result()
5746 
    result.read(self._iprot)
5747 
    self._iprot.readMessageEnd()
5748 
    if result.success is not None:
5749 
      return result.success
5750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItems failed: unknown result");
5751 
 
5752 
  def searchFlipkartItems(self, searchTerm, offset, limit):
5753 
    """
5754 
    Parameters:
5755 
     - searchTerm
5756 
     - offset
5757 
     - limit
5758 
    """
5759 
    self.send_searchFlipkartItems(searchTerm, offset, limit)
5760 
    return self.recv_searchFlipkartItems()
5761 
 
5762 
  def send_searchFlipkartItems(self, searchTerm, offset, limit):
5763 
    self._oprot.writeMessageBegin('searchFlipkartItems', TMessageType.CALL, self._seqid)
5764 
    args = searchFlipkartItems_args()
5765 
    args.searchTerm = searchTerm
5766 
    args.offset = offset
5767 
    args.limit = limit
5768 
    args.write(self._oprot)
5769 
    self._oprot.writeMessageEnd()
5770 
    self._oprot.trans.flush()
5771 
 
5772 
  def recv_searchFlipkartItems(self, ):
5773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5774 
    if mtype == TMessageType.EXCEPTION:
5775 
      x = TApplicationException()
5776 
      x.read(self._iprot)
5777 
      self._iprot.readMessageEnd()
5778 
      raise x
5779 
    result = searchFlipkartItems_result()
5780 
    result.read(self._iprot)
5781 
    self._iprot.readMessageEnd()
5782 
    if result.success is not None:
5783 
      return result.success
5784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchFlipkartItems failed: unknown result");
5785 
 
5786 
  def getCountForFlipkartItems(self, ):
5787 
    self.send_getCountForFlipkartItems()
5788 
    return self.recv_getCountForFlipkartItems()
5789 
 
5790 
  def send_getCountForFlipkartItems(self, ):
5791 
    self._oprot.writeMessageBegin('getCountForFlipkartItems', TMessageType.CALL, self._seqid)
5792 
    args = getCountForFlipkartItems_args()
5793 
    args.write(self._oprot)
5794 
    self._oprot.writeMessageEnd()
5795 
    self._oprot.trans.flush()
5796 
 
5797 
  def recv_getCountForFlipkartItems(self, ):
5798 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5799 
    if mtype == TMessageType.EXCEPTION:
5800 
      x = TApplicationException()
5801 
      x.read(self._iprot)
5802 
      self._iprot.readMessageEnd()
5803 
      raise x
5804 
    result = getCountForFlipkartItems_result()
5805 
    result.read(self._iprot)
5806 
    self._iprot.readMessageEnd()
5807 
    if result.success is not None:
5808 
      return result.success
5809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForFlipkartItems failed: unknown result");
5810 
 
5811 
  def getFlipkartSearchResultCount(self, searchTerm):
5812 
    """
5813 
    Parameters:
5814 
     - searchTerm
5815 
    """
5816 
    self.send_getFlipkartSearchResultCount(searchTerm)
5817 
    return self.recv_getFlipkartSearchResultCount()
5818 
 
5819 
  def send_getFlipkartSearchResultCount(self, searchTerm):
5820 
    self._oprot.writeMessageBegin('getFlipkartSearchResultCount', TMessageType.CALL, self._seqid)
5821 
    args = getFlipkartSearchResultCount_args()
5822 
    args.searchTerm = searchTerm
5823 
    args.write(self._oprot)
5824 
    self._oprot.writeMessageEnd()
5825 
    self._oprot.trans.flush()
5826 
 
5827 
  def recv_getFlipkartSearchResultCount(self, ):
5828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5829 
    if mtype == TMessageType.EXCEPTION:
5830 
      x = TApplicationException()
5831 
      x.read(self._iprot)
5832 
      self._iprot.readMessageEnd()
5833 
      raise x
5834 
    result = getFlipkartSearchResultCount_result()
5835 
    result.read(self._iprot)
5836 
    self._iprot.readMessageEnd()
5837 
    if result.success is not None:
5838 
      return result.success
5839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartSearchResultCount failed: unknown result");
5840 
 
5841 
  def getAllFkItems(self, ):
5842 
    self.send_getAllFkItems()
5843 
    return self.recv_getAllFkItems()
5844 
 
5845 
  def send_getAllFkItems(self, ):
5846 
    self._oprot.writeMessageBegin('getAllFkItems', TMessageType.CALL, self._seqid)
5847 
    args = getAllFkItems_args()
5848 
    args.write(self._oprot)
5849 
    self._oprot.writeMessageEnd()
5850 
    self._oprot.trans.flush()
5851 
 
5852 
  def recv_getAllFkItems(self, ):
5853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5854 
    if mtype == TMessageType.EXCEPTION:
5855 
      x = TApplicationException()
5856 
      x.read(self._iprot)
5857 
      self._iprot.readMessageEnd()
5858 
      raise x
5859 
    result = getAllFkItems_result()
5860 
    result.read(self._iprot)
5861 
    self._iprot.readMessageEnd()
5862 
    if result.success is not None:
5863 
      return result.success
5864 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFkItems failed: unknown result");
5865 
 
10140 vikram.rag 5866 
  def getFlipkartItemBySkyAtFlipkart(self, sku):
5867 
    """
5868 
    Parameters:
5869 
     - sku
5870 
    """
5871 
    self.send_getFlipkartItemBySkyAtFlipkart(sku)
5872 
    return self.recv_getFlipkartItemBySkyAtFlipkart()
10097 kshitij.so 5873 
 
10140 vikram.rag 5874 
  def send_getFlipkartItemBySkyAtFlipkart(self, sku):
5875 
    self._oprot.writeMessageBegin('getFlipkartItemBySkyAtFlipkart', TMessageType.CALL, self._seqid)
5876 
    args = getFlipkartItemBySkyAtFlipkart_args()
5877 
    args.sku = sku
5878 
    args.write(self._oprot)
5879 
    self._oprot.writeMessageEnd()
5880 
    self._oprot.trans.flush()
5881 
 
5882 
  def recv_getFlipkartItemBySkyAtFlipkart(self, ):
5883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5884 
    if mtype == TMessageType.EXCEPTION:
5885 
      x = TApplicationException()
5886 
      x.read(self._iprot)
5887 
      self._iprot.readMessageEnd()
5888 
      raise x
5889 
    result = getFlipkartItemBySkyAtFlipkart_result()
5890 
    result.read(self._iprot)
5891 
    self._iprot.readMessageEnd()
5892 
    if result.success is not None:
5893 
      return result.success
5894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemBySkyAtFlipkart failed: unknown result");
5895 
 
11015 kshitij.so 5896 
  def getMarketplaceHistory(self, source, offset, itemId):
5897 
    """
5898 
    Parameters:
5899 
     - source
5900 
     - offset
5901 
     - itemId
5902 
    """
5903 
    self.send_getMarketplaceHistory(source, offset, itemId)
5904 
    return self.recv_getMarketplaceHistory()
5905 
 
5906 
  def send_getMarketplaceHistory(self, source, offset, itemId):
5907 
    self._oprot.writeMessageBegin('getMarketplaceHistory', TMessageType.CALL, self._seqid)
5908 
    args = getMarketplaceHistory_args()
5909 
    args.source = source
5910 
    args.offset = offset
5911 
    args.itemId = itemId
5912 
    args.write(self._oprot)
5913 
    self._oprot.writeMessageEnd()
5914 
    self._oprot.trans.flush()
5915 
 
5916 
  def recv_getMarketplaceHistory(self, ):
5917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5918 
    if mtype == TMessageType.EXCEPTION:
5919 
      x = TApplicationException()
5920 
      x.read(self._iprot)
5921 
      self._iprot.readMessageEnd()
5922 
      raise x
5923 
    result = getMarketplaceHistory_result()
5924 
    result.read(self._iprot)
5925 
    self._iprot.readMessageEnd()
5926 
    if result.success is not None:
5927 
      return result.success
5928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistory failed: unknown result");
5929 
 
10909 vikram.rag 5930 
  def getAllFbbListedItems(self, ):
5931 
    self.send_getAllFbbListedItems()
5932 
    return self.recv_getAllFbbListedItems()
10140 vikram.rag 5933 
 
10909 vikram.rag 5934 
  def send_getAllFbbListedItems(self, ):
5935 
    self._oprot.writeMessageBegin('getAllFbbListedItems', TMessageType.CALL, self._seqid)
5936 
    args = getAllFbbListedItems_args()
5937 
    args.write(self._oprot)
5938 
    self._oprot.writeMessageEnd()
5939 
    self._oprot.trans.flush()
5940 
 
5941 
  def recv_getAllFbbListedItems(self, ):
5942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5943 
    if mtype == TMessageType.EXCEPTION:
5944 
      x = TApplicationException()
5945 
      x.read(self._iprot)
5946 
      self._iprot.readMessageEnd()
5947 
      raise x
5948 
    result = getAllFbbListedItems_result()
5949 
    result.read(self._iprot)
5950 
    self._iprot.readMessageEnd()
5951 
    if result.success is not None:
5952 
      return result.success
5953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbListedItems failed: unknown result");
5954 
 
10924 vikram.rag 5955 
  def getAllFbbPricingItems(self, ):
5956 
    self.send_getAllFbbPricingItems()
5957 
    return self.recv_getAllFbbPricingItems()
10909 vikram.rag 5958 
 
10924 vikram.rag 5959 
  def send_getAllFbbPricingItems(self, ):
5960 
    self._oprot.writeMessageBegin('getAllFbbPricingItems', TMessageType.CALL, self._seqid)
5961 
    args = getAllFbbPricingItems_args()
5962 
    args.write(self._oprot)
5963 
    self._oprot.writeMessageEnd()
5964 
    self._oprot.trans.flush()
5965 
 
5966 
  def recv_getAllFbbPricingItems(self, ):
5967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5968 
    if mtype == TMessageType.EXCEPTION:
5969 
      x = TApplicationException()
5970 
      x.read(self._iprot)
5971 
      self._iprot.readMessageEnd()
5972 
      raise x
5973 
    result = getAllFbbPricingItems_result()
5974 
    result.read(self._iprot)
5975 
    self._iprot.readMessageEnd()
5976 
    if result.success is not None:
5977 
      return result.success
5978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbPricingItems failed: unknown result");
5979 
 
11015 kshitij.so 5980 
  def getCountForMarketplaceHistory(self, source, itemId):
5981 
    """
5982 
    Parameters:
5983 
     - source
5984 
     - itemId
5985 
    """
5986 
    self.send_getCountForMarketplaceHistory(source, itemId)
5987 
    return self.recv_getCountForMarketplaceHistory()
10924 vikram.rag 5988 
 
11015 kshitij.so 5989 
  def send_getCountForMarketplaceHistory(self, source, itemId):
5990 
    self._oprot.writeMessageBegin('getCountForMarketplaceHistory', TMessageType.CALL, self._seqid)
5991 
    args = getCountForMarketplaceHistory_args()
5992 
    args.source = source
5993 
    args.itemId = itemId
5994 
    args.write(self._oprot)
5995 
    self._oprot.writeMessageEnd()
5996 
    self._oprot.trans.flush()
5997 
 
5998 
  def recv_getCountForMarketplaceHistory(self, ):
5999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6000 
    if mtype == TMessageType.EXCEPTION:
6001 
      x = TApplicationException()
6002 
      x.read(self._iprot)
6003 
      self._iprot.readMessageEnd()
6004 
      raise x
6005 
    result = getCountForMarketplaceHistory_result()
6006 
    result.read(self._iprot)
6007 
    self._iprot.readMessageEnd()
6008 
    if result.success is not None:
6009 
      return result.success
6010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForMarketplaceHistory failed: unknown result");
6011 
 
6012 
  def getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6013 
    """
6014 
    Parameters:
6015 
     - source
6016 
     - startDate
6017 
     - endDate
6018 
     - offset
6019 
     - limit
6020 
     - itemId
6021 
    """
6022 
    self.send_getMarketplaceHistoryByDate(source, startDate, endDate, offset, limit, itemId)
6023 
    return self.recv_getMarketplaceHistoryByDate()
6024 
 
6025 
  def send_getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6026 
    self._oprot.writeMessageBegin('getMarketplaceHistoryByDate', TMessageType.CALL, self._seqid)
6027 
    args = getMarketplaceHistoryByDate_args()
6028 
    args.source = source
6029 
    args.startDate = startDate
6030 
    args.endDate = endDate
6031 
    args.offset = offset
6032 
    args.limit = limit
6033 
    args.itemId = itemId
6034 
    args.write(self._oprot)
6035 
    self._oprot.writeMessageEnd()
6036 
    self._oprot.trans.flush()
6037 
 
6038 
  def recv_getMarketplaceHistoryByDate(self, ):
6039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6040 
    if mtype == TMessageType.EXCEPTION:
6041 
      x = TApplicationException()
6042 
      x.read(self._iprot)
6043 
      self._iprot.readMessageEnd()
6044 
      raise x
6045 
    result = getMarketplaceHistoryByDate_result()
6046 
    result.read(self._iprot)
6047 
    self._iprot.readMessageEnd()
6048 
    if result.success is not None:
6049 
      return result.success
6050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistoryByDate failed: unknown result");
6051 
 
11531 vikram.rag 6052 
  def getPrivateDealDetails(self, item_id):
6053 
    """
6054 
    Parameters:
6055 
     - item_id
6056 
    """
6057 
    self.send_getPrivateDealDetails(item_id)
6058 
    return self.recv_getPrivateDealDetails()
11015 kshitij.so 6059 
 
11531 vikram.rag 6060 
  def send_getPrivateDealDetails(self, item_id):
6061 
    self._oprot.writeMessageBegin('getPrivateDealDetails', TMessageType.CALL, self._seqid)
6062 
    args = getPrivateDealDetails_args()
6063 
    args.item_id = item_id
6064 
    args.write(self._oprot)
6065 
    self._oprot.writeMessageEnd()
6066 
    self._oprot.trans.flush()
6067 
 
6068 
  def recv_getPrivateDealDetails(self, ):
6069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6070 
    if mtype == TMessageType.EXCEPTION:
6071 
      x = TApplicationException()
6072 
      x.read(self._iprot)
6073 
      self._iprot.readMessageEnd()
6074 
      raise x
6075 
    result = getPrivateDealDetails_result()
6076 
    result.read(self._iprot)
6077 
    self._iprot.readMessageEnd()
6078 
    if result.success is not None:
6079 
      return result.success
6080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealDetails failed: unknown result");
6081 
 
6082 
  def getPrivateDealItems(self, offset, limit):
6083 
    """
6084 
    Parameters:
6085 
     - offset
6086 
     - limit
6087 
    """
6088 
    self.send_getPrivateDealItems(offset, limit)
6089 
    return self.recv_getPrivateDealItems()
6090 
 
6091 
  def send_getPrivateDealItems(self, offset, limit):
6092 
    self._oprot.writeMessageBegin('getPrivateDealItems', TMessageType.CALL, self._seqid)
6093 
    args = getPrivateDealItems_args()
6094 
    args.offset = offset
6095 
    args.limit = limit
6096 
    args.write(self._oprot)
6097 
    self._oprot.writeMessageEnd()
6098 
    self._oprot.trans.flush()
6099 
 
6100 
  def recv_getPrivateDealItems(self, ):
6101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6102 
    if mtype == TMessageType.EXCEPTION:
6103 
      x = TApplicationException()
6104 
      x.read(self._iprot)
6105 
      self._iprot.readMessageEnd()
6106 
      raise x
6107 
    result = getPrivateDealItems_result()
6108 
    result.read(self._iprot)
6109 
    self._iprot.readMessageEnd()
6110 
    if result.success is not None:
6111 
      return result.success
6112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealItems failed: unknown result");
6113 
 
6114 
  def addOrUpdatePrivateDeal(self, privateDeal):
6115 
    """
6116 
    Parameters:
6117 
     - privateDeal
6118 
    """
6119 
    self.send_addOrUpdatePrivateDeal(privateDeal)
6120 
    return self.recv_addOrUpdatePrivateDeal()
6121 
 
6122 
  def send_addOrUpdatePrivateDeal(self, privateDeal):
6123 
    self._oprot.writeMessageBegin('addOrUpdatePrivateDeal', TMessageType.CALL, self._seqid)
6124 
    args = addOrUpdatePrivateDeal_args()
6125 
    args.privateDeal = privateDeal
6126 
    args.write(self._oprot)
6127 
    self._oprot.writeMessageEnd()
6128 
    self._oprot.trans.flush()
6129 
 
6130 
  def recv_addOrUpdatePrivateDeal(self, ):
6131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6132 
    if mtype == TMessageType.EXCEPTION:
6133 
      x = TApplicationException()
6134 
      x.read(self._iprot)
6135 
      self._iprot.readMessageEnd()
6136 
      raise x
6137 
    result = addOrUpdatePrivateDeal_result()
6138 
    result.read(self._iprot)
6139 
    self._iprot.readMessageEnd()
6140 
    if result.success is not None:
6141 
      return result.success
6142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdatePrivateDeal failed: unknown result");
6143 
 
6144 
 
5944 mandeep.dh 6145 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
6146 
  def __init__(self, handler):
6147 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
6148 
    self._processMap["addItem"] = Processor.process_addItem
6149 
    self._processMap["updateItem"] = Processor.process_updateItem
6150 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 6151 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 6152 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
6153 
    self._processMap["startItemOn"] = Processor.process_startItemOn
6154 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
6155 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
6156 
    self._processMap["getItem"] = Processor.process_getItem
6157 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
6158 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
6159 
    self._processMap["getAllItems"] = Processor.process_getAllItems
6160 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
6161 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
6162 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
6163 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
6164 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
6165 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
6166 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
6167 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
6168 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
6169 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
6170 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
6171 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
6172 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
6173 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
6174 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
6175 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
6176 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
6177 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
6178 
    self._processMap["addCategory"] = Processor.process_addCategory
6179 
    self._processMap["getCategory"] = Processor.process_getCategory
6180 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
6181 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
6182 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 6183 
    self._processMap["addTag"] = Processor.process_addTag
6184 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
6185 
    self._processMap["deleteTag"] = Processor.process_deleteTag
6186 
    self._processMap["getAllTags"] = Processor.process_getAllTags
6187 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 6188 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 6189 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 6190 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 6191 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
6192 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
6193 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
6194 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 6195 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 6196 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 6197 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
6198 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 6199 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
6200 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
6201 
    self._processMap["addCampaign"] = Processor.process_addCampaign
6202 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
6203 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
6204 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 6205 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 6206 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
6207 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
6208 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
6209 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
6210 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
6211 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
6212 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
6213 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
6214 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
6215 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
6216 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
6217 
    self._processMap["getAllSources"] = Processor.process_getAllSources
6218 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
6219 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
6220 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
6221 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
6222 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
6223 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
6224 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
6225 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
6226 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
6227 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
6228 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
6229 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
6230 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
6231 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 6232 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
6233 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 6234 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 6235 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 6236 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
6237 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 6238 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 6239 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 6240 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
6241 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 6242 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
6243 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 6244 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 6245 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 6246 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 6247 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 6248 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
6249 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
6250 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 6251 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
6252 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
6253 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 6254 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
6255 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
6256 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 6257 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 6258 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 6259 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 6260 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
6261 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 6262 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
6263 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
6264 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 6265 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 6266 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 6267 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
6268 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 6269 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 6270 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
6271 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 6272 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 6273 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 6274 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
6275 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
6276 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
6277 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 6278 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 6279 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 6280 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
6281 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
6282 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
6283 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
6284 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 6285 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
6286 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 6287 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 6288 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
6289 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
9861 rajveer 6290 
    self._processMap["updateItemHoldInventory"] = Processor.process_updateItemHoldInventory
9895 vikram.rag 6291 
    self._processMap["updateNlcAtMarketplaces"] = Processor.process_updateNlcAtMarketplaces
9945 vikram.rag 6292 
    self._processMap["getAllFlipkartItems"] = Processor.process_getAllFlipkartItems
10097 kshitij.so 6293 
    self._processMap["addOrUpdateFlipkartItem"] = Processor.process_addOrUpdateFlipkartItem
6294 
    self._processMap["getFlipkartItem"] = Processor.process_getFlipkartItem
6295 
    self._processMap["getFlipkartItemDetails"] = Processor.process_getFlipkartItemDetails
6296 
    self._processMap["getFlipkartItems"] = Processor.process_getFlipkartItems
6297 
    self._processMap["searchFlipkartItems"] = Processor.process_searchFlipkartItems
6298 
    self._processMap["getCountForFlipkartItems"] = Processor.process_getCountForFlipkartItems
6299 
    self._processMap["getFlipkartSearchResultCount"] = Processor.process_getFlipkartSearchResultCount
6300 
    self._processMap["getAllFkItems"] = Processor.process_getAllFkItems
10140 vikram.rag 6301 
    self._processMap["getFlipkartItemBySkyAtFlipkart"] = Processor.process_getFlipkartItemBySkyAtFlipkart
11015 kshitij.so 6302 
    self._processMap["getMarketplaceHistory"] = Processor.process_getMarketplaceHistory
10909 vikram.rag 6303 
    self._processMap["getAllFbbListedItems"] = Processor.process_getAllFbbListedItems
10924 vikram.rag 6304 
    self._processMap["getAllFbbPricingItems"] = Processor.process_getAllFbbPricingItems
11015 kshitij.so 6305 
    self._processMap["getCountForMarketplaceHistory"] = Processor.process_getCountForMarketplaceHistory
6306 
    self._processMap["getMarketplaceHistoryByDate"] = Processor.process_getMarketplaceHistoryByDate
11531 vikram.rag 6307 
    self._processMap["getPrivateDealDetails"] = Processor.process_getPrivateDealDetails
6308 
    self._processMap["getPrivateDealItems"] = Processor.process_getPrivateDealItems
6309 
    self._processMap["addOrUpdatePrivateDeal"] = Processor.process_addOrUpdatePrivateDeal
5944 mandeep.dh 6310 
 
6311 
  def process(self, iprot, oprot):
6312 
    (name, type, seqid) = iprot.readMessageBegin()
6313 
    if name not in self._processMap:
6314 
      iprot.skip(TType.STRUCT)
6315 
      iprot.readMessageEnd()
6316 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6317 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6318 
      x.write(oprot)
6319 
      oprot.writeMessageEnd()
6320 
      oprot.trans.flush()
6321 
      return
6322 
    else:
6323 
      self._processMap[name](self, seqid, iprot, oprot)
6324 
    return True
6325 
 
6326 
  def process_addItem(self, seqid, iprot, oprot):
6327 
    args = addItem_args()
6328 
    args.read(iprot)
6329 
    iprot.readMessageEnd()
6330 
    result = addItem_result()
6331 
    try:
6332 
      result.success = self._handler.addItem(args.item)
6333 
    except CatalogServiceException, cex:
6334 
      result.cex = cex
6335 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
6336 
    result.write(oprot)
6337 
    oprot.writeMessageEnd()
6338 
    oprot.trans.flush()
6339 
 
6340 
  def process_updateItem(self, seqid, iprot, oprot):
6341 
    args = updateItem_args()
6342 
    args.read(iprot)
6343 
    iprot.readMessageEnd()
6344 
    result = updateItem_result()
6345 
    try:
6346 
      result.success = self._handler.updateItem(args.item)
6347 
    except CatalogServiceException, cex:
6348 
      result.cex = cex
6349 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
6350 
    result.write(oprot)
6351 
    oprot.writeMessageEnd()
6352 
    oprot.trans.flush()
6353 
 
6354 
  def process_isActive(self, seqid, iprot, oprot):
6355 
    args = isActive_args()
6356 
    args.read(iprot)
6357 
    iprot.readMessageEnd()
6358 
    result = isActive_result()
6359 
    try:
6360 
      result.success = self._handler.isActive(args.itemId)
6361 
    except CatalogServiceException, isex:
6362 
      result.isex = isex
6363 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
6364 
    result.write(oprot)
6365 
    oprot.writeMessageEnd()
6366 
    oprot.trans.flush()
6367 
 
7438 amit.gupta 6368 
  def process_getItemsStatus(self, seqid, iprot, oprot):
6369 
    args = getItemsStatus_args()
6370 
    args.read(iprot)
6371 
    iprot.readMessageEnd()
6372 
    result = getItemsStatus_result()
6373 
    try:
6374 
      result.success = self._handler.getItemsStatus(args.itemIds)
6375 
    except CatalogServiceException, isex:
6376 
      result.isex = isex
6377 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
6378 
    result.write(oprot)
6379 
    oprot.writeMessageEnd()
6380 
    oprot.trans.flush()
6381 
 
5944 mandeep.dh 6382 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
6383 
    args = getItemStatusDescription_args()
6384 
    args.read(iprot)
6385 
    iprot.readMessageEnd()
6386 
    result = getItemStatusDescription_result()
6387 
    try:
6388 
      result.success = self._handler.getItemStatusDescription(args.itemId)
6389 
    except CatalogServiceException, isex:
6390 
      result.isex = isex
6391 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
6392 
    result.write(oprot)
6393 
    oprot.writeMessageEnd()
6394 
    oprot.trans.flush()
6395 
 
6396 
  def process_startItemOn(self, seqid, iprot, oprot):
6397 
    args = startItemOn_args()
6398 
    args.read(iprot)
6399 
    iprot.readMessageEnd()
6400 
    result = startItemOn_result()
6401 
    try:
6402 
      self._handler.startItemOn(args.item_id, args.timestamp)
6403 
    except CatalogServiceException, cex:
6404 
      result.cex = cex
6405 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
6406 
    result.write(oprot)
6407 
    oprot.writeMessageEnd()
6408 
    oprot.trans.flush()
6409 
 
6410 
  def process_retireItemOn(self, seqid, iprot, oprot):
6411 
    args = retireItemOn_args()
6412 
    args.read(iprot)
6413 
    iprot.readMessageEnd()
6414 
    result = retireItemOn_result()
6415 
    try:
6416 
      self._handler.retireItemOn(args.item_id, args.timestamp)
6417 
    except CatalogServiceException, cex:
6418 
      result.cex = cex
6419 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
6420 
    result.write(oprot)
6421 
    oprot.writeMessageEnd()
6422 
    oprot.trans.flush()
6423 
 
6424 
  def process_changeItemStatus(self, seqid, iprot, oprot):
6425 
    args = changeItemStatus_args()
6426 
    args.read(iprot)
6427 
    iprot.readMessageEnd()
6428 
    result = changeItemStatus_result()
6429 
    try:
6430 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
6431 
    except CatalogServiceException, cex:
6432 
      result.cex = cex
6433 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
6434 
    result.write(oprot)
6435 
    oprot.writeMessageEnd()
6436 
    oprot.trans.flush()
6437 
 
6438 
  def process_getItem(self, seqid, iprot, oprot):
6439 
    args = getItem_args()
6440 
    args.read(iprot)
6441 
    iprot.readMessageEnd()
6442 
    result = getItem_result()
6443 
    try:
6444 
      result.success = self._handler.getItem(args.item_id)
6445 
    except CatalogServiceException, cex:
6446 
      result.cex = cex
6447 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
6448 
    result.write(oprot)
6449 
    oprot.writeMessageEnd()
6450 
    oprot.trans.flush()
6451 
 
6452 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
6453 
    args = getItemsByCatalogId_args()
6454 
    args.read(iprot)
6455 
    iprot.readMessageEnd()
6456 
    result = getItemsByCatalogId_result()
6457 
    try:
6458 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
6459 
    except CatalogServiceException, cex:
6460 
      result.cex = cex
6461 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
6462 
    result.write(oprot)
6463 
    oprot.writeMessageEnd()
6464 
    oprot.trans.flush()
6465 
 
6466 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
6467 
    args = getValidItemsByCatalogId_args()
6468 
    args.read(iprot)
6469 
    iprot.readMessageEnd()
6470 
    result = getValidItemsByCatalogId_result()
6471 
    try:
6472 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
6473 
    except CatalogServiceException, cex:
6474 
      result.cex = cex
6475 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
6476 
    result.write(oprot)
6477 
    oprot.writeMessageEnd()
6478 
    oprot.trans.flush()
6479 
 
6480 
  def process_getAllItems(self, seqid, iprot, oprot):
6481 
    args = getAllItems_args()
6482 
    args.read(iprot)
6483 
    iprot.readMessageEnd()
6484 
    result = getAllItems_result()
6485 
    try:
6486 
      result.success = self._handler.getAllItems(args.isActive)
6487 
    except CatalogServiceException, cex:
6488 
      result.cex = cex
6489 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
6490 
    result.write(oprot)
6491 
    oprot.writeMessageEnd()
6492 
    oprot.trans.flush()
6493 
 
6494 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
6495 
    args = getAllItemsByStatus_args()
6496 
    args.read(iprot)
6497 
    iprot.readMessageEnd()
6498 
    result = getAllItemsByStatus_result()
6499 
    try:
6500 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
6501 
    except CatalogServiceException, cex:
6502 
      result.cex = cex
6503 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
6504 
    result.write(oprot)
6505 
    oprot.writeMessageEnd()
6506 
    oprot.trans.flush()
6507 
 
6508 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
6509 
    args = markItemAsContentComplete_args()
6510 
    args.read(iprot)
6511 
    iprot.readMessageEnd()
6512 
    result = markItemAsContentComplete_result()
6513 
    try:
9253 rajveer 6514 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 6515 
    except CatalogServiceException, cex:
6516 
      result.cex = cex
6517 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
6518 
    result.write(oprot)
6519 
    oprot.writeMessageEnd()
6520 
    oprot.trans.flush()
6521 
 
6522 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
6523 
    args = getAllItemsInRange_args()
6524 
    args.read(iprot)
6525 
    iprot.readMessageEnd()
6526 
    result = getAllItemsInRange_result()
6527 
    try:
6528 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
6529 
    except CatalogServiceException, cex:
6530 
      result.cex = cex
6531 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
6532 
    result.write(oprot)
6533 
    oprot.writeMessageEnd()
6534 
    oprot.trans.flush()
6535 
 
6536 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
6537 
    args = getAllItemsByStatusInRange_args()
6538 
    args.read(iprot)
6539 
    iprot.readMessageEnd()
6540 
    result = getAllItemsByStatusInRange_result()
6541 
    try:
6542 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
6543 
    except CatalogServiceException, cex:
6544 
      result.cex = cex
6545 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
6546 
    result.write(oprot)
6547 
    oprot.writeMessageEnd()
6548 
    oprot.trans.flush()
6549 
 
6550 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
6551 
    args = getItemCountByStatus_args()
6552 
    args.read(iprot)
6553 
    iprot.readMessageEnd()
6554 
    result = getItemCountByStatus_result()
6555 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
6556 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
6557 
    result.write(oprot)
6558 
    oprot.writeMessageEnd()
6559 
    oprot.trans.flush()
6560 
 
6561 
  def process_getBestSellers(self, seqid, iprot, oprot):
6562 
    args = getBestSellers_args()
6563 
    args.read(iprot)
6564 
    iprot.readMessageEnd()
6565 
    result = getBestSellers_result()
6566 
    try:
6567 
      result.success = self._handler.getBestSellers()
6568 
    except CatalogServiceException, isex:
6569 
      result.isex = isex
6570 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
6571 
    result.write(oprot)
6572 
    oprot.writeMessageEnd()
6573 
    oprot.trans.flush()
6574 
 
6575 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
6576 
    args = getBestSellersCatalogIds_args()
6577 
    args.read(iprot)
6578 
    iprot.readMessageEnd()
6579 
    result = getBestSellersCatalogIds_result()
6580 
    try:
6581 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6582 
    except CatalogServiceException, cex:
6583 
      result.cex = cex
6584 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
6585 
    result.write(oprot)
6586 
    oprot.writeMessageEnd()
6587 
    oprot.trans.flush()
6588 
 
6589 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
6590 
    args = getBestSellersCount_args()
6591 
    args.read(iprot)
6592 
    iprot.readMessageEnd()
6593 
    result = getBestSellersCount_result()
6594 
    try:
6595 
      result.success = self._handler.getBestSellersCount()
6596 
    except CatalogServiceException, cex:
6597 
      result.cex = cex
6598 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
6599 
    result.write(oprot)
6600 
    oprot.writeMessageEnd()
6601 
    oprot.trans.flush()
6602 
 
6603 
  def process_getBestDeals(self, seqid, iprot, oprot):
6604 
    args = getBestDeals_args()
6605 
    args.read(iprot)
6606 
    iprot.readMessageEnd()
6607 
    result = getBestDeals_result()
6608 
    try:
6609 
      result.success = self._handler.getBestDeals()
6610 
    except CatalogServiceException, isex:
6611 
      result.isex = isex
6612 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
6613 
    result.write(oprot)
6614 
    oprot.writeMessageEnd()
6615 
    oprot.trans.flush()
6616 
 
6617 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
6618 
    args = getBestDealsCatalogIds_args()
6619 
    args.read(iprot)
6620 
    iprot.readMessageEnd()
6621 
    result = getBestDealsCatalogIds_result()
6622 
    try:
6623 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6624 
    except CatalogServiceException, cex:
6625 
      result.cex = cex
6626 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
6627 
    result.write(oprot)
6628 
    oprot.writeMessageEnd()
6629 
    oprot.trans.flush()
6630 
 
6631 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
6632 
    args = getBestDealsCount_args()
6633 
    args.read(iprot)
6634 
    iprot.readMessageEnd()
6635 
    result = getBestDealsCount_result()
6636 
    try:
6637 
      result.success = self._handler.getBestDealsCount()
6638 
    except CatalogServiceException, cex:
6639 
      result.cex = cex
6640 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
6641 
    result.write(oprot)
6642 
    oprot.writeMessageEnd()
6643 
    oprot.trans.flush()
6644 
 
6645 
  def process_getComingSoon(self, seqid, iprot, oprot):
6646 
    args = getComingSoon_args()
6647 
    args.read(iprot)
6648 
    iprot.readMessageEnd()
6649 
    result = getComingSoon_result()
6650 
    try:
6651 
      result.success = self._handler.getComingSoon()
6652 
    except CatalogServiceException, isex:
6653 
      result.isex = isex
6654 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
6655 
    result.write(oprot)
6656 
    oprot.writeMessageEnd()
6657 
    oprot.trans.flush()
6658 
 
6659 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
6660 
    args = getComingSoonCatalogIds_args()
6661 
    args.read(iprot)
6662 
    iprot.readMessageEnd()
6663 
    result = getComingSoonCatalogIds_result()
6664 
    try:
6665 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6666 
    except CatalogServiceException, cex:
6667 
      result.cex = cex
6668 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
6669 
    result.write(oprot)
6670 
    oprot.writeMessageEnd()
6671 
    oprot.trans.flush()
6672 
 
6673 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
6674 
    args = getComingSoonCount_args()
6675 
    args.read(iprot)
6676 
    iprot.readMessageEnd()
6677 
    result = getComingSoonCount_result()
6678 
    try:
6679 
      result.success = self._handler.getComingSoonCount()
6680 
    except CatalogServiceException, cex:
6681 
      result.cex = cex
6682 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
6683 
    result.write(oprot)
6684 
    oprot.writeMessageEnd()
6685 
    oprot.trans.flush()
6686 
 
6687 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
6688 
    args = getLatestArrivals_args()
6689 
    args.read(iprot)
6690 
    iprot.readMessageEnd()
6691 
    result = getLatestArrivals_result()
6692 
    try:
6693 
      result.success = self._handler.getLatestArrivals()
6694 
    except CatalogServiceException, isex:
6695 
      result.isex = isex
6696 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
6697 
    result.write(oprot)
6698 
    oprot.writeMessageEnd()
6699 
    oprot.trans.flush()
6700 
 
6701 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
6702 
    args = getLatestArrivalsCatalogIds_args()
6703 
    args.read(iprot)
6704 
    iprot.readMessageEnd()
6705 
    result = getLatestArrivalsCatalogIds_result()
6706 
    try:
6707 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
6708 
    except CatalogServiceException, cex:
6709 
      result.cex = cex
6710 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
6711 
    result.write(oprot)
6712 
    oprot.writeMessageEnd()
6713 
    oprot.trans.flush()
6714 
 
6715 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
6716 
    args = getLatestArrivalsCount_args()
6717 
    args.read(iprot)
6718 
    iprot.readMessageEnd()
6719 
    result = getLatestArrivalsCount_result()
6720 
    try:
6721 
      result.success = self._handler.getLatestArrivalsCount()
6722 
    except CatalogServiceException, cex:
6723 
      result.cex = cex
6724 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
6725 
    result.write(oprot)
6726 
    oprot.writeMessageEnd()
6727 
    oprot.trans.flush()
6728 
 
6729 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
6730 
    args = generateNewEntityID_args()
6731 
    args.read(iprot)
6732 
    iprot.readMessageEnd()
6733 
    result = generateNewEntityID_result()
6734 
    result.success = self._handler.generateNewEntityID()
6735 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
6736 
    result.write(oprot)
6737 
    oprot.writeMessageEnd()
6738 
    oprot.trans.flush()
6739 
 
6740 
  def process_addCategory(self, seqid, iprot, oprot):
6741 
    args = addCategory_args()
6742 
    args.read(iprot)
6743 
    iprot.readMessageEnd()
6744 
    result = addCategory_result()
6745 
    result.success = self._handler.addCategory(args.category)
6746 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
6747 
    result.write(oprot)
6748 
    oprot.writeMessageEnd()
6749 
    oprot.trans.flush()
6750 
 
6751 
  def process_getCategory(self, seqid, iprot, oprot):
6752 
    args = getCategory_args()
6753 
    args.read(iprot)
6754 
    iprot.readMessageEnd()
6755 
    result = getCategory_result()
6756 
    result.success = self._handler.getCategory(args.id)
6757 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
6758 
    result.write(oprot)
6759 
    oprot.writeMessageEnd()
6760 
    oprot.trans.flush()
6761 
 
6762 
  def process_getAllCategories(self, seqid, iprot, oprot):
6763 
    args = getAllCategories_args()
6764 
    args.read(iprot)
6765 
    iprot.readMessageEnd()
6766 
    result = getAllCategories_result()
6767 
    result.success = self._handler.getAllCategories()
6768 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
6769 
    result.write(oprot)
6770 
    oprot.writeMessageEnd()
6771 
    oprot.trans.flush()
6772 
 
6773 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
6774 
    args = getAllSimilarItems_args()
6775 
    args.read(iprot)
6776 
    iprot.readMessageEnd()
6777 
    result = getAllSimilarItems_result()
6778 
    result.success = self._handler.getAllSimilarItems(args.itemId)
6779 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
6780 
    result.write(oprot)
6781 
    oprot.writeMessageEnd()
6782 
    oprot.trans.flush()
6783 
 
6784 
  def process_addSimilarItem(self, seqid, iprot, oprot):
6785 
    args = addSimilarItem_args()
6786 
    args.read(iprot)
6787 
    iprot.readMessageEnd()
6788 
    result = addSimilarItem_result()
6789 
    try:
6790 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
6791 
    except CatalogServiceException, cex:
6792 
      result.cex = cex
6793 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
6794 
    result.write(oprot)
6795 
    oprot.writeMessageEnd()
6796 
    oprot.trans.flush()
6797 
 
6512 kshitij.so 6798 
  def process_addTag(self, seqid, iprot, oprot):
6799 
    args = addTag_args()
6800 
    args.read(iprot)
6801 
    iprot.readMessageEnd()
6802 
    result = addTag_result()
6803 
    result.success = self._handler.addTag(args.displayName, args.itemId)
6804 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
6805 
    result.write(oprot)
6806 
    oprot.writeMessageEnd()
6807 
    oprot.trans.flush()
6808 
 
6809 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
6810 
    args = deleteEntityTag_args()
6811 
    args.read(iprot)
6812 
    iprot.readMessageEnd()
6813 
    result = deleteEntityTag_result()
6814 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
6815 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
6816 
    result.write(oprot)
6817 
    oprot.writeMessageEnd()
6818 
    oprot.trans.flush()
6819 
 
6820 
  def process_deleteTag(self, seqid, iprot, oprot):
6821 
    args = deleteTag_args()
6822 
    args.read(iprot)
6823 
    iprot.readMessageEnd()
6824 
    result = deleteTag_result()
6825 
    result.success = self._handler.deleteTag(args.displayName)
6826 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
6827 
    result.write(oprot)
6828 
    oprot.writeMessageEnd()
6829 
    oprot.trans.flush()
6830 
 
6831 
  def process_getAllTags(self, seqid, iprot, oprot):
6832 
    args = getAllTags_args()
6833 
    args.read(iprot)
6834 
    iprot.readMessageEnd()
6835 
    result = getAllTags_result()
6836 
    result.success = self._handler.getAllTags()
6837 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
6838 
    result.write(oprot)
6839 
    oprot.writeMessageEnd()
6840 
    oprot.trans.flush()
6841 
 
6842 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
6843 
    args = getAllEntitiesByTagName_args()
6844 
    args.read(iprot)
6845 
    iprot.readMessageEnd()
6846 
    result = getAllEntitiesByTagName_result()
6847 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
6848 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
6849 
    result.write(oprot)
6850 
    oprot.writeMessageEnd()
6851 
    oprot.trans.flush()
6852 
 
6845 amit.gupta 6853 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
6854 
    args = getAllEntityTags_args()
6855 
    args.read(iprot)
6856 
    iprot.readMessageEnd()
6857 
    result = getAllEntityTags_result()
6858 
    result.success = self._handler.getAllEntityTags()
6859 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
6860 
    result.write(oprot)
6861 
    oprot.writeMessageEnd()
6862 
    oprot.trans.flush()
6863 
 
6850 kshitij.so 6864 
  def process_addBanner(self, seqid, iprot, oprot):
6865 
    args = addBanner_args()
6866 
    args.read(iprot)
6867 
    iprot.readMessageEnd()
6868 
    result = addBanner_result()
10097 kshitij.so 6869 
    result.success = self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 6870 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
6871 
    result.write(oprot)
6872 
    oprot.writeMessageEnd()
6873 
    oprot.trans.flush()
6874 
 
8579 kshitij.so 6875 
  def process_updateBanner(self, seqid, iprot, oprot):
6876 
    args = updateBanner_args()
6877 
    args.read(iprot)
6878 
    iprot.readMessageEnd()
6879 
    result = updateBanner_result()
6880 
    result.success = self._handler.updateBanner(args.banner)
6881 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
6882 
    result.write(oprot)
6883 
    oprot.writeMessageEnd()
6884 
    oprot.trans.flush()
6885 
 
6850 kshitij.so 6886 
  def process_getAllBanners(self, seqid, iprot, oprot):
6887 
    args = getAllBanners_args()
6888 
    args.read(iprot)
6889 
    iprot.readMessageEnd()
6890 
    result = getAllBanners_result()
6891 
    result.success = self._handler.getAllBanners()
6892 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
6893 
    result.write(oprot)
6894 
    oprot.writeMessageEnd()
6895 
    oprot.trans.flush()
6896 
 
6897 
  def process_deleteBanner(self, seqid, iprot, oprot):
6898 
    args = deleteBanner_args()
6899 
    args.read(iprot)
6900 
    iprot.readMessageEnd()
6901 
    result = deleteBanner_result()
9155 kshitij.so 6902 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 6903 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
6904 
    result.write(oprot)
6905 
    oprot.writeMessageEnd()
6906 
    oprot.trans.flush()
6907 
 
6908 
  def process_getBannerDetails(self, seqid, iprot, oprot):
6909 
    args = getBannerDetails_args()
6910 
    args.read(iprot)
6911 
    iprot.readMessageEnd()
6912 
    result = getBannerDetails_result()
9155 kshitij.so 6913 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 6914 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
6915 
    result.write(oprot)
6916 
    oprot.writeMessageEnd()
6917 
    oprot.trans.flush()
6918 
 
6919 
  def process_getActiveBanners(self, seqid, iprot, oprot):
6920 
    args = getActiveBanners_args()
6921 
    args.read(iprot)
6922 
    iprot.readMessageEnd()
6923 
    result = getActiveBanners_result()
6924 
    result.success = self._handler.getActiveBanners()
6925 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
6926 
    result.write(oprot)
6927 
    oprot.writeMessageEnd()
6928 
    oprot.trans.flush()
6929 
 
6849 kshitij.so 6930 
  def process_addBannerMap(self, seqid, iprot, oprot):
6931 
    args = addBannerMap_args()
6932 
    args.read(iprot)
6933 
    iprot.readMessageEnd()
6934 
    result = addBannerMap_result()
8579 kshitij.so 6935 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 6936 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
6937 
    result.write(oprot)
6938 
    oprot.writeMessageEnd()
6939 
    oprot.trans.flush()
6940 
 
8579 kshitij.so 6941 
  def process_updateBannerMap(self, seqid, iprot, oprot):
6942 
    args = updateBannerMap_args()
6943 
    args.read(iprot)
6944 
    iprot.readMessageEnd()
6945 
    result = updateBannerMap_result()
6946 
    result.success = self._handler.updateBannerMap(args.bannerMap)
6947 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
6948 
    result.write(oprot)
6949 
    oprot.writeMessageEnd()
6950 
    oprot.trans.flush()
6951 
 
6849 kshitij.so 6952 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
6953 
    args = deleteBannerMap_args()
6954 
    args.read(iprot)
6955 
    iprot.readMessageEnd()
6956 
    result = deleteBannerMap_result()
6957 
    result.success = self._handler.deleteBannerMap(args.bannerName)
6958 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
6959 
    result.write(oprot)
6960 
    oprot.writeMessageEnd()
6961 
    oprot.trans.flush()
6962 
 
6963 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
6964 
    args = getBannerMapDetails_args()
6965 
    args.read(iprot)
6966 
    iprot.readMessageEnd()
6967 
    result = getBannerMapDetails_result()
9155 kshitij.so 6968 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 6969 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
6970 
    result.write(oprot)
6971 
    oprot.writeMessageEnd()
6972 
    oprot.trans.flush()
6973 
 
8579 kshitij.so 6974 
  def process_addBannerUri(self, seqid, iprot, oprot):
6975 
    args = addBannerUri_args()
6976 
    args.read(iprot)
6977 
    iprot.readMessageEnd()
6978 
    result = addBannerUri_result()
6979 
    self._handler.addBannerUri(args.bannerUriMappings)
6980 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
6981 
    result.write(oprot)
6982 
    oprot.writeMessageEnd()
6983 
    oprot.trans.flush()
6984 
 
6985 
  def process_getUriMapping(self, seqid, iprot, oprot):
6986 
    args = getUriMapping_args()
6987 
    args.read(iprot)
6988 
    iprot.readMessageEnd()
6989 
    result = getUriMapping_result()
9155 kshitij.so 6990 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 6991 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
6992 
    result.write(oprot)
6993 
    oprot.writeMessageEnd()
6994 
    oprot.trans.flush()
6995 
 
6996 
  def process_addCampaign(self, seqid, iprot, oprot):
6997 
    args = addCampaign_args()
6998 
    args.read(iprot)
6999 
    iprot.readMessageEnd()
7000 
    result = addCampaign_result()
7001 
    self._handler.addCampaign(args.campaign)
7002 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
7003 
    result.write(oprot)
7004 
    oprot.writeMessageEnd()
7005 
    oprot.trans.flush()
7006 
 
7007 
  def process_getCampaigns(self, seqid, iprot, oprot):
7008 
    args = getCampaigns_args()
7009 
    args.read(iprot)
7010 
    iprot.readMessageEnd()
7011 
    result = getCampaigns_result()
7012 
    result.success = self._handler.getCampaigns(args.campaignName)
7013 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
7014 
    result.write(oprot)
7015 
    oprot.writeMessageEnd()
7016 
    oprot.trans.flush()
7017 
 
7018 
  def process_deleteCampaign(self, seqid, iprot, oprot):
7019 
    args = deleteCampaign_args()
7020 
    args.read(iprot)
7021 
    iprot.readMessageEnd()
7022 
    result = deleteCampaign_result()
7023 
    self._handler.deleteCampaign(args.campaignId)
7024 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
7025 
    result.write(oprot)
7026 
    oprot.writeMessageEnd()
7027 
    oprot.trans.flush()
7028 
 
7029 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
7030 
    args = getAllCampaigns_args()
7031 
    args.read(iprot)
7032 
    iprot.readMessageEnd()
7033 
    result = getAllCampaigns_result()
7034 
    result.success = self._handler.getAllCampaigns()
7035 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
7036 
    result.write(oprot)
7037 
    oprot.writeMessageEnd()
7038 
    oprot.trans.flush()
7039 
 
9155 kshitij.so 7040 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
7041 
    args = getActiveBannersForMobileSite_args()
7042 
    args.read(iprot)
7043 
    iprot.readMessageEnd()
7044 
    result = getActiveBannersForMobileSite_result()
7045 
    result.success = self._handler.getActiveBannersForMobileSite()
7046 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
7047 
    result.write(oprot)
7048 
    oprot.writeMessageEnd()
7049 
    oprot.trans.flush()
7050 
 
5944 mandeep.dh 7051 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
7052 
    args = deleteSimilarItem_args()
7053 
    args.read(iprot)
7054 
    iprot.readMessageEnd()
7055 
    result = deleteSimilarItem_result()
7056 
    try:
7057 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
7058 
    except CatalogServiceException, cex:
7059 
      result.cex = cex
7060 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
7061 
    result.write(oprot)
7062 
    oprot.writeMessageEnd()
7063 
    oprot.trans.flush()
7064 
 
7065 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
7066 
    args = checkSimilarItem_args()
7067 
    args.read(iprot)
7068 
    iprot.readMessageEnd()
7069 
    result = checkSimilarItem_result()
7070 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
7071 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
7072 
    result.write(oprot)
7073 
    oprot.writeMessageEnd()
7074 
    oprot.trans.flush()
7075 
 
7076 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
7077 
    args = validateRiskyStatus_args()
7078 
    args.read(iprot)
7079 
    iprot.readMessageEnd()
7080 
    result = validateRiskyStatus_result()
7081 
    self._handler.validateRiskyStatus(args.itemId)
7082 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
7083 
    result.write(oprot)
7084 
    oprot.writeMessageEnd()
7085 
    oprot.trans.flush()
7086 
 
7087 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
7088 
    args = changeItemRiskyFlag_args()
7089 
    args.read(iprot)
7090 
    iprot.readMessageEnd()
7091 
    result = changeItemRiskyFlag_result()
7092 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
7093 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
7094 
    result.write(oprot)
7095 
    oprot.writeMessageEnd()
7096 
    oprot.trans.flush()
7097 
 
7098 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
7099 
    args = getItemsByRiskyFlag_args()
7100 
    args.read(iprot)
7101 
    iprot.readMessageEnd()
7102 
    result = getItemsByRiskyFlag_result()
7103 
    result.success = self._handler.getItemsByRiskyFlag()
7104 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
7105 
    result.write(oprot)
7106 
    oprot.writeMessageEnd()
7107 
    oprot.trans.flush()
7108 
 
7109 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
7110 
    args = getItemsForMasterSheet_args()
7111 
    args.read(iprot)
7112 
    iprot.readMessageEnd()
7113 
    result = getItemsForMasterSheet_result()
7114 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
7115 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
7116 
    result.write(oprot)
7117 
    oprot.writeMessageEnd()
7118 
    oprot.trans.flush()
7119 
 
7120 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
7121 
    args = getSimilarItemsCatalogIds_args()
7122 
    args.read(iprot)
7123 
    iprot.readMessageEnd()
7124 
    result = getSimilarItemsCatalogIds_result()
7125 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
7126 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
7127 
    result.write(oprot)
7128 
    oprot.writeMessageEnd()
7129 
    oprot.trans.flush()
7130 
 
7131 
  def process_addProductNotification(self, seqid, iprot, oprot):
7132 
    args = addProductNotification_args()
7133 
    args.read(iprot)
7134 
    iprot.readMessageEnd()
7135 
    result = addProductNotification_result()
7136 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
7137 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
7138 
    result.write(oprot)
7139 
    oprot.writeMessageEnd()
7140 
    oprot.trans.flush()
7141 
 
7142 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
7143 
    args = sendProductNotifications_args()
7144 
    args.read(iprot)
7145 
    iprot.readMessageEnd()
7146 
    result = sendProductNotifications_result()
7147 
    result.success = self._handler.sendProductNotifications()
7148 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
7149 
    result.write(oprot)
7150 
    oprot.writeMessageEnd()
7151 
    oprot.trans.flush()
7152 
 
7153 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
7154 
    args = getAllBrandsByCategory_args()
7155 
    args.read(iprot)
7156 
    iprot.readMessageEnd()
7157 
    result = getAllBrandsByCategory_result()
7158 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
7159 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
7160 
    result.write(oprot)
7161 
    oprot.writeMessageEnd()
7162 
    oprot.trans.flush()
7163 
 
7164 
  def process_getAllBrands(self, seqid, iprot, oprot):
7165 
    args = getAllBrands_args()
7166 
    args.read(iprot)
7167 
    iprot.readMessageEnd()
7168 
    result = getAllBrands_result()
7169 
    result.success = self._handler.getAllBrands()
7170 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
7171 
    result.write(oprot)
7172 
    oprot.writeMessageEnd()
7173 
    oprot.trans.flush()
7174 
 
7175 
  def process_getAllSources(self, seqid, iprot, oprot):
7176 
    args = getAllSources_args()
7177 
    args.read(iprot)
7178 
    iprot.readMessageEnd()
7179 
    result = getAllSources_result()
7180 
    result.success = self._handler.getAllSources()
7181 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
7182 
    result.write(oprot)
7183 
    oprot.writeMessageEnd()
7184 
    oprot.trans.flush()
7185 
 
7186 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
7187 
    args = getItemPricingBySource_args()
7188 
    args.read(iprot)
7189 
    iprot.readMessageEnd()
7190 
    result = getItemPricingBySource_result()
7191 
    try:
7192 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
7193 
    except CatalogServiceException, cex:
7194 
      result.cex = cex
7195 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
7196 
    result.write(oprot)
7197 
    oprot.writeMessageEnd()
7198 
    oprot.trans.flush()
7199 
 
7200 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
7201 
    args = addSourceItemPricing_args()
7202 
    args.read(iprot)
7203 
    iprot.readMessageEnd()
7204 
    result = addSourceItemPricing_result()
7205 
    try:
7206 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
7207 
    except CatalogServiceException, cex:
7208 
      result.cex = cex
7209 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
7210 
    result.write(oprot)
7211 
    oprot.writeMessageEnd()
7212 
    oprot.trans.flush()
7213 
 
7214 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
7215 
    args = getAllSourcePricing_args()
7216 
    args.read(iprot)
7217 
    iprot.readMessageEnd()
7218 
    result = getAllSourcePricing_result()
7219 
    try:
7220 
      result.success = self._handler.getAllSourcePricing(args.itemId)
7221 
    except CatalogServiceException, cex:
7222 
      result.cex = cex
7223 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
7224 
    result.write(oprot)
7225 
    oprot.writeMessageEnd()
7226 
    oprot.trans.flush()
7227 
 
7228 
  def process_getItemForSource(self, seqid, iprot, oprot):
7229 
    args = getItemForSource_args()
7230 
    args.read(iprot)
7231 
    iprot.readMessageEnd()
7232 
    result = getItemForSource_result()
7233 
    try:
7234 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
7235 
    except CatalogServiceException, cex:
7236 
      result.cex = cex
7237 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
7238 
    result.write(oprot)
7239 
    oprot.writeMessageEnd()
7240 
    oprot.trans.flush()
7241 
 
7242 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
7243 
    args = searchItemsInRange_args()
7244 
    args.read(iprot)
7245 
    iprot.readMessageEnd()
7246 
    result = searchItemsInRange_result()
7247 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
7248 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
7249 
    result.write(oprot)
7250 
    oprot.writeMessageEnd()
7251 
    oprot.trans.flush()
7252 
 
7253 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
7254 
    args = getSearchResultCount_args()
7255 
    args.read(iprot)
7256 
    iprot.readMessageEnd()
7257 
    result = getSearchResultCount_result()
7258 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
7259 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
7260 
    result.write(oprot)
7261 
    oprot.writeMessageEnd()
7262 
    oprot.trans.flush()
7263 
 
7264 
  def process_getProductNotifications(self, seqid, iprot, oprot):
7265 
    args = getProductNotifications_args()
7266 
    args.read(iprot)
7267 
    iprot.readMessageEnd()
7268 
    result = getProductNotifications_result()
7269 
    result.success = self._handler.getProductNotifications(args.startDateTime)
7270 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
7271 
    result.write(oprot)
7272 
    oprot.writeMessageEnd()
7273 
    oprot.trans.flush()
7274 
 
7275 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
7276 
    args = getProductNotificationRequestCount_args()
7277 
    args.read(iprot)
7278 
    iprot.readMessageEnd()
7279 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 7280 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 7281 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
7282 
    result.write(oprot)
7283 
    oprot.writeMessageEnd()
7284 
    oprot.trans.flush()
7285 
 
7286 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
7287 
    args = addAuthorizationLog_args()
7288 
    args.read(iprot)
7289 
    iprot.readMessageEnd()
7290 
    result = addAuthorizationLog_result()
7291 
    try:
7292 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
7293 
    except CatalogServiceException, cex:
7294 
      result.cex = cex
7295 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
7296 
    result.write(oprot)
7297 
    oprot.writeMessageEnd()
7298 
    oprot.trans.flush()
7299 
 
7300 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
7301 
    args = addupdateVoucherForItem_args()
7302 
    args.read(iprot)
7303 
    iprot.readMessageEnd()
7304 
    result = addupdateVoucherForItem_result()
7305 
    try:
7306 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
7307 
    except CatalogServiceException, cex:
7308 
      result.cex = cex
7309 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
7310 
    result.write(oprot)
7311 
    oprot.writeMessageEnd()
7312 
    oprot.trans.flush()
7313 
 
7314 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
7315 
    args = deleteVoucherForItem_args()
7316 
    args.read(iprot)
7317 
    iprot.readMessageEnd()
7318 
    result = deleteVoucherForItem_result()
7319 
    try:
7320 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
7321 
    except CatalogServiceException, cex:
7322 
      result.cex = cex
7323 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
7324 
    result.write(oprot)
7325 
    oprot.writeMessageEnd()
7326 
    oprot.trans.flush()
7327 
 
7328 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
7329 
    args = getVoucherAmount_args()
7330 
    args.read(iprot)
7331 
    iprot.readMessageEnd()
7332 
    result = getVoucherAmount_result()
7333 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
7334 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
7335 
    result.write(oprot)
7336 
    oprot.writeMessageEnd()
7337 
    oprot.trans.flush()
7338 
 
7339 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
7340 
    args = getAllItemVouchers_args()
7341 
    args.read(iprot)
7342 
    iprot.readMessageEnd()
7343 
    result = getAllItemVouchers_result()
7344 
    result.success = self._handler.getAllItemVouchers(args.itemId)
7345 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
7346 
    result.write(oprot)
7347 
    oprot.writeMessageEnd()
7348 
    oprot.trans.flush()
7349 
 
7350 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
7351 
    args = isValidCatalogItemId_args()
7352 
    args.read(iprot)
7353 
    iprot.readMessageEnd()
7354 
    result = isValidCatalogItemId_result()
7355 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
7356 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
7357 
    result.write(oprot)
7358 
    oprot.writeMessageEnd()
7359 
    oprot.trans.flush()
7360 
 
6039 amit.gupta 7361 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
7362 
    args = getVatPercentageForItem_args()
7363 
    args.read(iprot)
7364 
    iprot.readMessageEnd()
7365 
    result = getVatPercentageForItem_result()
7340 amit.gupta 7366 
    try:
7367 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
7368 
    except CatalogServiceException, cex:
7369 
      result.cex = cex
6039 amit.gupta 7370 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
7371 
    result.write(oprot)
7372 
    oprot.writeMessageEnd()
7373 
    oprot.trans.flush()
5944 mandeep.dh 7374 
 
6039 amit.gupta 7375 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
7376 
    args = getVatAmountForItem_args()
7377 
    args.read(iprot)
7378 
    iprot.readMessageEnd()
7379 
    result = getVatAmountForItem_result()
7380 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
7381 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
7382 
    result.write(oprot)
7383 
    oprot.writeMessageEnd()
7384 
    oprot.trans.flush()
7385 
 
6531 vikram.rag 7386 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
7387 
    args = getAllIgnoredInventoryUpdateItemsList_args()
7388 
    args.read(iprot)
7389 
    iprot.readMessageEnd()
7390 
    result = getAllIgnoredInventoryUpdateItemsList_result()
7391 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
7392 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
7393 
    result.write(oprot)
7394 
    oprot.writeMessageEnd()
7395 
    oprot.trans.flush()
6039 amit.gupta 7396 
 
6821 amar.kumar 7397 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
7398 
    args = getAllAliveItems_args()
7399 
    args.read(iprot)
7400 
    iprot.readMessageEnd()
7401 
    result = getAllAliveItems_result()
7402 
    result.success = self._handler.getAllAliveItems()
7403 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
7404 
    result.write(oprot)
7405 
    oprot.writeMessageEnd()
7406 
    oprot.trans.flush()
7407 
 
6805 anupam.sin 7408 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
7409 
    args = getInsuranceAmount_args()
7410 
    args.read(iprot)
7411 
    iprot.readMessageEnd()
7412 
    result = getInsuranceAmount_result()
6921 anupam.sin 7413 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 7414 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
7415 
    result.write(oprot)
7416 
    oprot.writeMessageEnd()
7417 
    oprot.trans.flush()
6531 vikram.rag 7418 
 
6805 anupam.sin 7419 
  def process_getInsurer(self, seqid, iprot, oprot):
7420 
    args = getInsurer_args()
7421 
    args.read(iprot)
7422 
    iprot.readMessageEnd()
7423 
    result = getInsurer_result()
7424 
    result.success = self._handler.getInsurer(args.insurerId)
7425 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
7426 
    result.write(oprot)
7427 
    oprot.writeMessageEnd()
7428 
    oprot.trans.flush()
7429 
 
6838 vikram.rag 7430 
  def process_getAllInsurers(self, seqid, iprot, oprot):
7431 
    args = getAllInsurers_args()
7432 
    args.read(iprot)
7433 
    iprot.readMessageEnd()
7434 
    result = getAllInsurers_result()
7435 
    result.success = self._handler.getAllInsurers()
7436 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
7437 
    result.write(oprot)
7438 
    oprot.writeMessageEnd()
7439 
    oprot.trans.flush()
6805 anupam.sin 7440 
 
6962 rajveer 7441 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
7442 
    args = updateInsuranceDeclaredAmount_args()
7443 
    args.read(iprot)
7444 
    iprot.readMessageEnd()
7445 
    result = updateInsuranceDeclaredAmount_result()
7446 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
7447 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
7448 
    result.write(oprot)
7449 
    oprot.writeMessageEnd()
7450 
    oprot.trans.flush()
6838 vikram.rag 7451 
 
7190 amar.kumar 7452 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
7453 
    args = getFreebieForItem_args()
7454 
    args.read(iprot)
7455 
    iprot.readMessageEnd()
7456 
    result = getFreebieForItem_result()
7457 
    result.success = self._handler.getFreebieForItem(args.itemId)
7458 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
7459 
    result.write(oprot)
7460 
    oprot.writeMessageEnd()
7461 
    oprot.trans.flush()
6962 rajveer 7462 
 
7190 amar.kumar 7463 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
7464 
    args = addOrUpdateFreebieForItem_args()
7465 
    args.read(iprot)
7466 
    iprot.readMessageEnd()
7467 
    result = addOrUpdateFreebieForItem_result()
7468 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
7469 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
7470 
    result.write(oprot)
7471 
    oprot.writeMessageEnd()
7472 
    oprot.trans.flush()
7473 
 
7272 amit.gupta 7474 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
7475 
    args = addOrUpdateBrandInfo_args()
7476 
    args.read(iprot)
7477 
    iprot.readMessageEnd()
7478 
    result = addOrUpdateBrandInfo_result()
7479 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
7480 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
7481 
    result.write(oprot)
7482 
    oprot.writeMessageEnd()
7483 
    oprot.trans.flush()
7484 
 
7485 
  def process_getBrandInfo(self, seqid, iprot, oprot):
7486 
    args = getBrandInfo_args()
7487 
    args.read(iprot)
7488 
    iprot.readMessageEnd()
7489 
    result = getBrandInfo_result()
7490 
    result.success = self._handler.getBrandInfo()
7491 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
7492 
    result.write(oprot)
7493 
    oprot.writeMessageEnd()
7494 
    oprot.trans.flush()
7495 
 
7256 rajveer 7496 
  def process_getStorePricing(self, seqid, iprot, oprot):
7497 
    args = getStorePricing_args()
7498 
    args.read(iprot)
7499 
    iprot.readMessageEnd()
7500 
    result = getStorePricing_result()
7501 
    result.success = self._handler.getStorePricing(args.itemId)
7502 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
7503 
    result.write(oprot)
7504 
    oprot.writeMessageEnd()
7505 
    oprot.trans.flush()
7190 amar.kumar 7506 
 
7306 rajveer 7507 
  def process_getStorePricings(self, seqid, iprot, oprot):
7508 
    args = getStorePricings_args()
7509 
    args.read(iprot)
7510 
    iprot.readMessageEnd()
7511 
    result = getStorePricings_result()
7512 
    result.success = self._handler.getStorePricings(args.itemIds)
7513 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
7514 
    result.write(oprot)
7515 
    oprot.writeMessageEnd()
7516 
    oprot.trans.flush()
7517 
 
7265 rajveer 7518 
  def process_updateStorePricing(self, seqid, iprot, oprot):
7519 
    args = updateStorePricing_args()
7520 
    args.read(iprot)
7521 
    iprot.readMessageEnd()
7522 
    result = updateStorePricing_result()
7382 rajveer 7523 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 7524 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
7525 
    result.write(oprot)
7526 
    oprot.writeMessageEnd()
7527 
    oprot.trans.flush()
7256 rajveer 7528 
 
7281 kshitij.so 7529 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
7530 
    args = getAllAmazonListedItems_args()
7531 
    args.read(iprot)
7532 
    iprot.readMessageEnd()
7533 
    result = getAllAmazonListedItems_result()
7534 
    result.success = self._handler.getAllAmazonListedItems()
7535 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
7536 
    result.write(oprot)
7537 
    oprot.writeMessageEnd()
7538 
    oprot.trans.flush()
7265 rajveer 7539 
 
8619 kshitij.so 7540 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
7541 
    args = searchAmazonItems_args()
7542 
    args.read(iprot)
7543 
    iprot.readMessageEnd()
7544 
    result = searchAmazonItems_result()
7545 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
7546 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
7547 
    result.write(oprot)
7548 
    oprot.writeMessageEnd()
7549 
    oprot.trans.flush()
7550 
 
7551 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
7552 
    args = getAmazonSearchResultCount_args()
7553 
    args.read(iprot)
7554 
    iprot.readMessageEnd()
7555 
    result = getAmazonSearchResultCount_result()
7556 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
7557 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
7558 
    result.write(oprot)
7559 
    oprot.writeMessageEnd()
7560 
    oprot.trans.flush()
7561 
 
7562 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
7563 
    args = getCountForAmazonlistedItems_args()
7564 
    args.read(iprot)
7565 
    iprot.readMessageEnd()
7566 
    result = getCountForAmazonlistedItems_result()
7567 
    result.success = self._handler.getCountForAmazonlistedItems()
7568 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
7569 
    result.write(oprot)
7570 
    oprot.writeMessageEnd()
7571 
    oprot.trans.flush()
7572 
 
7281 kshitij.so 7573 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
7574 
    args = getAmazonItemDetails_args()
7575 
    args.read(iprot)
7576 
    iprot.readMessageEnd()
7577 
    result = getAmazonItemDetails_result()
7578 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
7579 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
7580 
    result.write(oprot)
7581 
    oprot.writeMessageEnd()
7582 
    oprot.trans.flush()
7583 
 
7584 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
7585 
    args = updateAmazonItemDetails_args()
7586 
    args.read(iprot)
7587 
    iprot.readMessageEnd()
7588 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 7589 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 7590 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
7591 
    result.write(oprot)
7592 
    oprot.writeMessageEnd()
7593 
    oprot.trans.flush()
7594 
 
7595 
  def process_addAmazonItem(self, seqid, iprot, oprot):
7596 
    args = addAmazonItem_args()
7597 
    args.read(iprot)
7598 
    iprot.readMessageEnd()
7599 
    result = addAmazonItem_result()
7600 
    self._handler.addAmazonItem(args.amazonlisted)
7601 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
7602 
    result.write(oprot)
7603 
    oprot.writeMessageEnd()
7604 
    oprot.trans.flush()
7605 
 
7291 vikram.rag 7606 
  def process_getAsinItems(self, seqid, iprot, oprot):
7607 
    args = getAsinItems_args()
7608 
    args.read(iprot)
7609 
    iprot.readMessageEnd()
7610 
    result = getAsinItems_result()
7611 
    result.success = self._handler.getAsinItems()
7612 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
7613 
    result.write(oprot)
7614 
    oprot.writeMessageEnd()
7615 
    oprot.trans.flush()
7281 kshitij.so 7616 
 
7291 vikram.rag 7617 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
7618 
    args = getAllFbaListedItems_args()
7619 
    args.read(iprot)
7620 
    iprot.readMessageEnd()
7621 
    result = getAllFbaListedItems_result()
7622 
    result.success = self._handler.getAllFbaListedItems()
7623 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
7624 
    result.write(oprot)
7625 
    oprot.writeMessageEnd()
7626 
    oprot.trans.flush()
7627 
 
7628 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
7629 
    args = getAllNonFbaListedItems_args()
7630 
    args.read(iprot)
7631 
    iprot.readMessageEnd()
7632 
    result = getAllNonFbaListedItems_result()
7633 
    result.success = self._handler.getAllNonFbaListedItems()
7634 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
7635 
    result.write(oprot)
7636 
    oprot.writeMessageEnd()
7637 
    oprot.trans.flush()
7638 
 
7460 kshitij.so 7639 
  def process_updateItemInventory(self, seqid, iprot, oprot):
7640 
    args = updateItemInventory_args()
7641 
    args.read(iprot)
7642 
    iprot.readMessageEnd()
7643 
    result = updateItemInventory_result()
7644 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
7645 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
7646 
    result.write(oprot)
7647 
    oprot.writeMessageEnd()
7648 
    oprot.trans.flush()
7291 vikram.rag 7649 
 
7770 kshitij.so 7650 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
7651 
    args = updateTimestampForAmazonFeeds_args()
7652 
    args.read(iprot)
7653 
    iprot.readMessageEnd()
7654 
    result = updateTimestampForAmazonFeeds_result()
7655 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
7656 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
7657 
    result.write(oprot)
7658 
    oprot.writeMessageEnd()
7659 
    oprot.trans.flush()
7460 kshitij.so 7660 
 
7897 amar.kumar 7661 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
7662 
    args = getAllParentCategories_args()
7663 
    args.read(iprot)
7664 
    iprot.readMessageEnd()
7665 
    result = getAllParentCategories_result()
7666 
    result.success = self._handler.getAllParentCategories()
7667 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
7668 
    result.write(oprot)
7669 
    oprot.writeMessageEnd()
7670 
    oprot.trans.flush()
7770 kshitij.so 7671 
 
7977 kshitij.so 7672 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
7673 
    args = addPageViewEvent_args()
7674 
    args.read(iprot)
7675 
    iprot.readMessageEnd()
7676 
    result = addPageViewEvent_result()
7677 
    self._handler.addPageViewEvent(args.pageViewEvents)
7678 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
7679 
    result.write(oprot)
7680 
    oprot.writeMessageEnd()
7681 
    oprot.trans.flush()
7897 amar.kumar 7682 
 
7977 kshitij.so 7683 
  def process_addCartEvent(self, seqid, iprot, oprot):
7684 
    args = addCartEvent_args()
7685 
    args.read(iprot)
7686 
    iprot.readMessageEnd()
7687 
    result = addCartEvent_result()
7688 
    self._handler.addCartEvent(args.cartEvents)
7689 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
7690 
    result.write(oprot)
7691 
    oprot.writeMessageEnd()
7692 
    oprot.trans.flush()
7693 
 
8182 amar.kumar 7694 
  def process_addEbayItem(self, seqid, iprot, oprot):
7695 
    args = addEbayItem_args()
7696 
    args.read(iprot)
7697 
    iprot.readMessageEnd()
7698 
    result = addEbayItem_result()
7699 
    self._handler.addEbayItem(args.ebayItem)
7700 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
7701 
    result.write(oprot)
7702 
    oprot.writeMessageEnd()
7703 
    oprot.trans.flush()
7704 
 
7705 
  def process_getEbayItem(self, seqid, iprot, oprot):
7706 
    args = getEbayItem_args()
7707 
    args.read(iprot)
7708 
    iprot.readMessageEnd()
7709 
    result = getEbayItem_result()
7710 
    result.success = self._handler.getEbayItem(args.listingId)
7711 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
7712 
    result.write(oprot)
7713 
    oprot.writeMessageEnd()
7714 
    oprot.trans.flush()
7715 
 
7716 
  def process_updateEbayItem(self, seqid, iprot, oprot):
7717 
    args = updateEbayItem_args()
7718 
    args.read(iprot)
7719 
    iprot.readMessageEnd()
7720 
    result = updateEbayItem_result()
7721 
    self._handler.updateEbayItem(args.ebayItem)
7722 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
7723 
    result.write(oprot)
7724 
    oprot.writeMessageEnd()
7725 
    oprot.trans.flush()
7726 
 
8139 kshitij.so 7727 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
7728 
    args = getAmazonListedItems_args()
7729 
    args.read(iprot)
7730 
    iprot.readMessageEnd()
7731 
    result = getAmazonListedItems_result()
7732 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
7733 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
7734 
    result.write(oprot)
7735 
    oprot.writeMessageEnd()
7736 
    oprot.trans.flush()
7977 kshitij.so 7737 
 
8168 kshitij.so 7738 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
7739 
    args = updateAmazonAttributesInBulk_args()
7740 
    args.read(iprot)
7741 
    iprot.readMessageEnd()
7742 
    result = updateAmazonAttributesInBulk_result()
7743 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
7744 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
7745 
    result.write(oprot)
7746 
    oprot.writeMessageEnd()
7747 
    oprot.trans.flush()
8139 kshitij.so 7748 
 
8379 vikram.rag 7749 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
7750 
    args = getAllItemstoListOnFba_args()
7751 
    args.read(iprot)
7752 
    iprot.readMessageEnd()
7753 
    result = getAllItemstoListOnFba_result()
7754 
    result.success = self._handler.getAllItemstoListOnFba()
7755 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
7756 
    result.write(oprot)
7757 
    oprot.writeMessageEnd()
7758 
    oprot.trans.flush()
8168 kshitij.so 7759 
 
8379 vikram.rag 7760 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
7761 
    args = getAllItemstoListOnNonFba_args()
7762 
    args.read(iprot)
7763 
    iprot.readMessageEnd()
7764 
    result = getAllItemstoListOnNonFba_result()
7765 
    result.success = self._handler.getAllItemstoListOnNonFba()
7766 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
7767 
    result.write(oprot)
7768 
    oprot.writeMessageEnd()
7769 
    oprot.trans.flush()
7770 
 
8619 kshitij.so 7771 
  def process_updateAsin(self, seqid, iprot, oprot):
7772 
    args = updateAsin_args()
7773 
    args.read(iprot)
7774 
    iprot.readMessageEnd()
7775 
    result = updateAsin_result()
7776 
    self._handler.updateAsin(args.item)
7777 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
7778 
    result.write(oprot)
7779 
    oprot.writeMessageEnd()
7780 
    oprot.trans.flush()
8616 vikram.rag 7781 
 
8739 vikram.rag 7782 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
7783 
    args = addOrUpdateSnapdealItem_args()
7784 
    args.read(iprot)
7785 
    iprot.readMessageEnd()
7786 
    result = addOrUpdateSnapdealItem_result()
7787 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
7788 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
7789 
    result.write(oprot)
7790 
    oprot.writeMessageEnd()
7791 
    oprot.trans.flush()
8619 kshitij.so 7792 
 
8739 vikram.rag 7793 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
7794 
    args = getSnapdealItem_args()
7795 
    args.read(iprot)
7796 
    iprot.readMessageEnd()
7797 
    result = getSnapdealItem_result()
7798 
    result.success = self._handler.getSnapdealItem(args.item_id)
7799 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
7800 
    result.write(oprot)
7801 
    oprot.writeMessageEnd()
7802 
    oprot.trans.flush()
7803 
 
9242 kshitij.so 7804 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
7805 
    args = getSnapdealItemDetails_args()
7806 
    args.read(iprot)
7807 
    iprot.readMessageEnd()
7808 
    result = getSnapdealItemDetails_result()
7809 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
7810 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
7811 
    result.write(oprot)
7812 
    oprot.writeMessageEnd()
7813 
    oprot.trans.flush()
7814 
 
8739 vikram.rag 7815 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
7816 
    args = getAllSnapdealItems_args()
7817 
    args.read(iprot)
7818 
    iprot.readMessageEnd()
7819 
    result = getAllSnapdealItems_result()
7820 
    result.success = self._handler.getAllSnapdealItems()
7821 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
7822 
    result.write(oprot)
7823 
    oprot.writeMessageEnd()
7824 
    oprot.trans.flush()
7825 
 
9242 kshitij.so 7826 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
7827 
    args = getSnapdealItems_args()
7828 
    args.read(iprot)
7829 
    iprot.readMessageEnd()
7830 
    result = getSnapdealItems_result()
7831 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
7832 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
7833 
    result.write(oprot)
7834 
    oprot.writeMessageEnd()
7835 
    oprot.trans.flush()
8739 vikram.rag 7836 
 
9242 kshitij.so 7837 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
7838 
    args = searchSnapdealItems_args()
7839 
    args.read(iprot)
7840 
    iprot.readMessageEnd()
7841 
    result = searchSnapdealItems_result()
7842 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
7843 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
7844 
    result.write(oprot)
7845 
    oprot.writeMessageEnd()
7846 
    oprot.trans.flush()
7847 
 
7848 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
7849 
    args = getCountForSnapdealItems_args()
7850 
    args.read(iprot)
7851 
    iprot.readMessageEnd()
7852 
    result = getCountForSnapdealItems_result()
7853 
    result.success = self._handler.getCountForSnapdealItems()
7854 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
7855 
    result.write(oprot)
7856 
    oprot.writeMessageEnd()
7857 
    oprot.trans.flush()
7858 
 
7859 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
7860 
    args = getSnapdealSearchResultCount_args()
7861 
    args.read(iprot)
7862 
    iprot.readMessageEnd()
7863 
    result = getSnapdealSearchResultCount_result()
7864 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
7865 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
7866 
    result.write(oprot)
7867 
    oprot.writeMessageEnd()
7868 
    oprot.trans.flush()
7869 
 
9299 kshitij.so 7870 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
7871 
    args = getPrefferedInsurerForItem_args()
7872 
    args.read(iprot)
7873 
    iprot.readMessageEnd()
7874 
    result = getPrefferedInsurerForItem_result()
7875 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
7876 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
7877 
    result.write(oprot)
7878 
    oprot.writeMessageEnd()
7879 
    oprot.trans.flush()
9242 kshitij.so 7880 
 
9456 vikram.rag 7881 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
7882 
    args = getSnapdealItembySkuAtSnapdeal_args()
7883 
    args.read(iprot)
7884 
    iprot.readMessageEnd()
7885 
    result = getSnapdealItembySkuAtSnapdeal_result()
7886 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
7887 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
7888 
    result.write(oprot)
7889 
    oprot.writeMessageEnd()
7890 
    oprot.trans.flush()
9299 kshitij.so 7891 
 
9621 manish.sha 7892 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
7893 
    args = getProductFeedSubmit_args()
7894 
    args.read(iprot)
7895 
    iprot.readMessageEnd()
7896 
    result = getProductFeedSubmit_result()
7897 
    try:
7898 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
7899 
    except CatalogServiceException, cex:
7900 
      result.cex = cex
7901 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
7902 
    result.write(oprot)
7903 
    oprot.writeMessageEnd()
7904 
    oprot.trans.flush()
9456 vikram.rag 7905 
 
9621 manish.sha 7906 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
7907 
    args = addProductFeedSubmit_args()
7908 
    args.read(iprot)
7909 
    iprot.readMessageEnd()
7910 
    result = addProductFeedSubmit_result()
7911 
    try:
7912 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
7913 
    except CatalogServiceException, cex:
7914 
      result.cex = cex
7915 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
7916 
    result.write(oprot)
7917 
    oprot.writeMessageEnd()
7918 
    oprot.trans.flush()
7919 
 
7920 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
7921 
    args = updateProductFeedSubmit_args()
7922 
    args.read(iprot)
7923 
    iprot.readMessageEnd()
7924 
    result = updateProductFeedSubmit_result()
7925 
    try:
7926 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
7927 
    except CatalogServiceException, cex:
7928 
      result.cex = cex
7929 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
7930 
    result.write(oprot)
7931 
    oprot.writeMessageEnd()
7932 
    oprot.trans.flush()
7933 
 
7934 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
7935 
    args = deleteProductFeedSubmit_args()
7936 
    args.read(iprot)
7937 
    iprot.readMessageEnd()
7938 
    result = deleteProductFeedSubmit_result()
7939 
    try:
7940 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
7941 
    except CatalogServiceException, cex:
7942 
      result.cex = cex
7943 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
7944 
    result.write(oprot)
7945 
    oprot.writeMessageEnd()
7946 
    oprot.trans.flush()
7947 
 
7948 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
7949 
    args = getAllProductFeedSubmit_args()
7950 
    args.read(iprot)
7951 
    iprot.readMessageEnd()
7952 
    result = getAllProductFeedSubmit_result()
7953 
    try:
7954 
      result.success = self._handler.getAllProductFeedSubmit()
7955 
    except CatalogServiceException, cex:
7956 
      result.cex = cex
7957 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
7958 
    result.write(oprot)
7959 
    oprot.writeMessageEnd()
7960 
    oprot.trans.flush()
7961 
 
9724 kshitij.so 7962 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
7963 
    args = getMarketplacedetailsForItem_args()
7964 
    args.read(iprot)
7965 
    iprot.readMessageEnd()
7966 
    result = getMarketplacedetailsForItem_result()
7967 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
7968 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
7969 
    result.write(oprot)
7970 
    oprot.writeMessageEnd()
7971 
    oprot.trans.flush()
9621 manish.sha 7972 
 
9724 kshitij.so 7973 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
7974 
    args = updateMarketplaceAttributesForItem_args()
7975 
    args.read(iprot)
7976 
    iprot.readMessageEnd()
7977 
    result = updateMarketplaceAttributesForItem_result()
7978 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
7979 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
7980 
    result.write(oprot)
7981 
    oprot.writeMessageEnd()
7982 
    oprot.trans.flush()
7983 
 
9779 kshitij.so 7984 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
7985 
    args = getCostingForMarketplace_args()
7986 
    args.read(iprot)
7987 
    iprot.readMessageEnd()
7988 
    result = getCostingForMarketplace_result()
7989 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
7990 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
7991 
    result.write(oprot)
7992 
    oprot.writeMessageEnd()
7993 
    oprot.trans.flush()
7994 
 
9776 vikram.rag 7995 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
7996 
    args = getMarketPlaceItemsForPriceUpdate_args()
7997 
    args.read(iprot)
7998 
    iprot.readMessageEnd()
7999 
    result = getMarketPlaceItemsForPriceUpdate_result()
8000 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
8001 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
8002 
    result.write(oprot)
8003 
    oprot.writeMessageEnd()
8004 
    oprot.trans.flush()
9724 kshitij.so 8005 
 
9776 vikram.rag 8006 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
8007 
    args = updateMarketPlacePriceUpdateStatus_args()
8008 
    args.read(iprot)
8009 
    iprot.readMessageEnd()
8010 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 8011 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 8012 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
8013 
    result.write(oprot)
8014 
    oprot.writeMessageEnd()
8015 
    oprot.trans.flush()
8016 
 
9861 rajveer 8017 
  def process_updateItemHoldInventory(self, seqid, iprot, oprot):
8018 
    args = updateItemHoldInventory_args()
8019 
    args.read(iprot)
8020 
    iprot.readMessageEnd()
8021 
    result = updateItemHoldInventory_result()
8022 
    self._handler.updateItemHoldInventory(args.itemHoldMap)
8023 
    oprot.writeMessageBegin("updateItemHoldInventory", TMessageType.REPLY, seqid)
8024 
    result.write(oprot)
8025 
    oprot.writeMessageEnd()
8026 
    oprot.trans.flush()
9776 vikram.rag 8027 
 
9895 vikram.rag 8028 
  def process_updateNlcAtMarketplaces(self, seqid, iprot, oprot):
8029 
    args = updateNlcAtMarketplaces_args()
8030 
    args.read(iprot)
8031 
    iprot.readMessageEnd()
8032 
    result = updateNlcAtMarketplaces_result()
8033 
    self._handler.updateNlcAtMarketplaces(args.item_id, args.vendor_id, args.nlc)
8034 
    oprot.writeMessageBegin("updateNlcAtMarketplaces", TMessageType.REPLY, seqid)
8035 
    result.write(oprot)
8036 
    oprot.writeMessageEnd()
8037 
    oprot.trans.flush()
9861 rajveer 8038 
 
9945 vikram.rag 8039 
  def process_getAllFlipkartItems(self, seqid, iprot, oprot):
8040 
    args = getAllFlipkartItems_args()
8041 
    args.read(iprot)
8042 
    iprot.readMessageEnd()
8043 
    result = getAllFlipkartItems_result()
8044 
    result.success = self._handler.getAllFlipkartItems()
8045 
    oprot.writeMessageBegin("getAllFlipkartItems", TMessageType.REPLY, seqid)
8046 
    result.write(oprot)
8047 
    oprot.writeMessageEnd()
8048 
    oprot.trans.flush()
9895 vikram.rag 8049 
 
10097 kshitij.so 8050 
  def process_addOrUpdateFlipkartItem(self, seqid, iprot, oprot):
8051 
    args = addOrUpdateFlipkartItem_args()
8052 
    args.read(iprot)
8053 
    iprot.readMessageEnd()
8054 
    result = addOrUpdateFlipkartItem_result()
8055 
    result.success = self._handler.addOrUpdateFlipkartItem(args.flipkartitem)
8056 
    oprot.writeMessageBegin("addOrUpdateFlipkartItem", TMessageType.REPLY, seqid)
8057 
    result.write(oprot)
8058 
    oprot.writeMessageEnd()
8059 
    oprot.trans.flush()
9945 vikram.rag 8060 
 
10097 kshitij.so 8061 
  def process_getFlipkartItem(self, seqid, iprot, oprot):
8062 
    args = getFlipkartItem_args()
8063 
    args.read(iprot)
8064 
    iprot.readMessageEnd()
8065 
    result = getFlipkartItem_result()
8066 
    result.success = self._handler.getFlipkartItem(args.item_id)
8067 
    oprot.writeMessageBegin("getFlipkartItem", TMessageType.REPLY, seqid)
8068 
    result.write(oprot)
8069 
    oprot.writeMessageEnd()
8070 
    oprot.trans.flush()
8071 
 
8072 
  def process_getFlipkartItemDetails(self, seqid, iprot, oprot):
8073 
    args = getFlipkartItemDetails_args()
8074 
    args.read(iprot)
8075 
    iprot.readMessageEnd()
8076 
    result = getFlipkartItemDetails_result()
8077 
    result.success = self._handler.getFlipkartItemDetails(args.item_id)
8078 
    oprot.writeMessageBegin("getFlipkartItemDetails", TMessageType.REPLY, seqid)
8079 
    result.write(oprot)
8080 
    oprot.writeMessageEnd()
8081 
    oprot.trans.flush()
8082 
 
8083 
  def process_getFlipkartItems(self, seqid, iprot, oprot):
8084 
    args = getFlipkartItems_args()
8085 
    args.read(iprot)
8086 
    iprot.readMessageEnd()
8087 
    result = getFlipkartItems_result()
8088 
    result.success = self._handler.getFlipkartItems(args.offset, args.limit)
8089 
    oprot.writeMessageBegin("getFlipkartItems", TMessageType.REPLY, seqid)
8090 
    result.write(oprot)
8091 
    oprot.writeMessageEnd()
8092 
    oprot.trans.flush()
8093 
 
8094 
  def process_searchFlipkartItems(self, seqid, iprot, oprot):
8095 
    args = searchFlipkartItems_args()
8096 
    args.read(iprot)
8097 
    iprot.readMessageEnd()
8098 
    result = searchFlipkartItems_result()
8099 
    result.success = self._handler.searchFlipkartItems(args.searchTerm, args.offset, args.limit)
8100 
    oprot.writeMessageBegin("searchFlipkartItems", TMessageType.REPLY, seqid)
8101 
    result.write(oprot)
8102 
    oprot.writeMessageEnd()
8103 
    oprot.trans.flush()
8104 
 
8105 
  def process_getCountForFlipkartItems(self, seqid, iprot, oprot):
8106 
    args = getCountForFlipkartItems_args()
8107 
    args.read(iprot)
8108 
    iprot.readMessageEnd()
8109 
    result = getCountForFlipkartItems_result()
8110 
    result.success = self._handler.getCountForFlipkartItems()
8111 
    oprot.writeMessageBegin("getCountForFlipkartItems", TMessageType.REPLY, seqid)
8112 
    result.write(oprot)
8113 
    oprot.writeMessageEnd()
8114 
    oprot.trans.flush()
8115 
 
8116 
  def process_getFlipkartSearchResultCount(self, seqid, iprot, oprot):
8117 
    args = getFlipkartSearchResultCount_args()
8118 
    args.read(iprot)
8119 
    iprot.readMessageEnd()
8120 
    result = getFlipkartSearchResultCount_result()
8121 
    result.success = self._handler.getFlipkartSearchResultCount(args.searchTerm)
8122 
    oprot.writeMessageBegin("getFlipkartSearchResultCount", TMessageType.REPLY, seqid)
8123 
    result.write(oprot)
8124 
    oprot.writeMessageEnd()
8125 
    oprot.trans.flush()
8126 
 
8127 
  def process_getAllFkItems(self, seqid, iprot, oprot):
8128 
    args = getAllFkItems_args()
8129 
    args.read(iprot)
8130 
    iprot.readMessageEnd()
8131 
    result = getAllFkItems_result()
8132 
    result.success = self._handler.getAllFkItems()
8133 
    oprot.writeMessageBegin("getAllFkItems", TMessageType.REPLY, seqid)
8134 
    result.write(oprot)
8135 
    oprot.writeMessageEnd()
8136 
    oprot.trans.flush()
8137 
 
10140 vikram.rag 8138 
  def process_getFlipkartItemBySkyAtFlipkart(self, seqid, iprot, oprot):
8139 
    args = getFlipkartItemBySkyAtFlipkart_args()
8140 
    args.read(iprot)
8141 
    iprot.readMessageEnd()
8142 
    result = getFlipkartItemBySkyAtFlipkart_result()
8143 
    result.success = self._handler.getFlipkartItemBySkyAtFlipkart(args.sku)
8144 
    oprot.writeMessageBegin("getFlipkartItemBySkyAtFlipkart", TMessageType.REPLY, seqid)
8145 
    result.write(oprot)
8146 
    oprot.writeMessageEnd()
8147 
    oprot.trans.flush()
10097 kshitij.so 8148 
 
11015 kshitij.so 8149 
  def process_getMarketplaceHistory(self, seqid, iprot, oprot):
8150 
    args = getMarketplaceHistory_args()
8151 
    args.read(iprot)
8152 
    iprot.readMessageEnd()
8153 
    result = getMarketplaceHistory_result()
8154 
    result.success = self._handler.getMarketplaceHistory(args.source, args.offset, args.itemId)
8155 
    oprot.writeMessageBegin("getMarketplaceHistory", TMessageType.REPLY, seqid)
8156 
    result.write(oprot)
8157 
    oprot.writeMessageEnd()
8158 
    oprot.trans.flush()
8159 
 
10909 vikram.rag 8160 
  def process_getAllFbbListedItems(self, seqid, iprot, oprot):
8161 
    args = getAllFbbListedItems_args()
8162 
    args.read(iprot)
8163 
    iprot.readMessageEnd()
8164 
    result = getAllFbbListedItems_result()
8165 
    result.success = self._handler.getAllFbbListedItems()
8166 
    oprot.writeMessageBegin("getAllFbbListedItems", TMessageType.REPLY, seqid)
8167 
    result.write(oprot)
8168 
    oprot.writeMessageEnd()
8169 
    oprot.trans.flush()
10140 vikram.rag 8170 
 
10924 vikram.rag 8171 
  def process_getAllFbbPricingItems(self, seqid, iprot, oprot):
8172 
    args = getAllFbbPricingItems_args()
8173 
    args.read(iprot)
8174 
    iprot.readMessageEnd()
8175 
    result = getAllFbbPricingItems_result()
8176 
    result.success = self._handler.getAllFbbPricingItems()
8177 
    oprot.writeMessageBegin("getAllFbbPricingItems", TMessageType.REPLY, seqid)
8178 
    result.write(oprot)
8179 
    oprot.writeMessageEnd()
8180 
    oprot.trans.flush()
10909 vikram.rag 8181 
 
11015 kshitij.so 8182 
  def process_getCountForMarketplaceHistory(self, seqid, iprot, oprot):
8183 
    args = getCountForMarketplaceHistory_args()
8184 
    args.read(iprot)
8185 
    iprot.readMessageEnd()
8186 
    result = getCountForMarketplaceHistory_result()
8187 
    result.success = self._handler.getCountForMarketplaceHistory(args.source, args.itemId)
8188 
    oprot.writeMessageBegin("getCountForMarketplaceHistory", TMessageType.REPLY, seqid)
8189 
    result.write(oprot)
8190 
    oprot.writeMessageEnd()
8191 
    oprot.trans.flush()
10924 vikram.rag 8192 
 
11015 kshitij.so 8193 
  def process_getMarketplaceHistoryByDate(self, seqid, iprot, oprot):
8194 
    args = getMarketplaceHistoryByDate_args()
8195 
    args.read(iprot)
8196 
    iprot.readMessageEnd()
8197 
    result = getMarketplaceHistoryByDate_result()
8198 
    result.success = self._handler.getMarketplaceHistoryByDate(args.source, args.startDate, args.endDate, args.offset, args.limit, args.itemId)
8199 
    oprot.writeMessageBegin("getMarketplaceHistoryByDate", TMessageType.REPLY, seqid)
8200 
    result.write(oprot)
8201 
    oprot.writeMessageEnd()
8202 
    oprot.trans.flush()
8203 
 
11531 vikram.rag 8204 
  def process_getPrivateDealDetails(self, seqid, iprot, oprot):
8205 
    args = getPrivateDealDetails_args()
8206 
    args.read(iprot)
8207 
    iprot.readMessageEnd()
8208 
    result = getPrivateDealDetails_result()
8209 
    result.success = self._handler.getPrivateDealDetails(args.item_id)
8210 
    oprot.writeMessageBegin("getPrivateDealDetails", TMessageType.REPLY, seqid)
8211 
    result.write(oprot)
8212 
    oprot.writeMessageEnd()
8213 
    oprot.trans.flush()
11015 kshitij.so 8214 
 
11531 vikram.rag 8215 
  def process_getPrivateDealItems(self, seqid, iprot, oprot):
8216 
    args = getPrivateDealItems_args()
8217 
    args.read(iprot)
8218 
    iprot.readMessageEnd()
8219 
    result = getPrivateDealItems_result()
8220 
    result.success = self._handler.getPrivateDealItems(args.offset, args.limit)
8221 
    oprot.writeMessageBegin("getPrivateDealItems", TMessageType.REPLY, seqid)
8222 
    result.write(oprot)
8223 
    oprot.writeMessageEnd()
8224 
    oprot.trans.flush()
8225 
 
8226 
  def process_addOrUpdatePrivateDeal(self, seqid, iprot, oprot):
8227 
    args = addOrUpdatePrivateDeal_args()
8228 
    args.read(iprot)
8229 
    iprot.readMessageEnd()
8230 
    result = addOrUpdatePrivateDeal_result()
8231 
    result.success = self._handler.addOrUpdatePrivateDeal(args.privateDeal)
8232 
    oprot.writeMessageBegin("addOrUpdatePrivateDeal", TMessageType.REPLY, seqid)
8233 
    result.write(oprot)
8234 
    oprot.writeMessageEnd()
8235 
    oprot.trans.flush()
8236 
 
8237 
 
5944 mandeep.dh 8238 
# HELPER FUNCTIONS AND STRUCTURES
8239 
 
8240 
class addItem_args:
8241 
  """
8242 
  Attributes:
8243 
   - item
8244 
  """
8245 
 
8246 
  thrift_spec = (
8247 
    None, # 0
8248 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
8249 
  )
8250 
 
8251 
  def __init__(self, item=None,):
8252 
    self.item = item
8253 
 
8254 
  def read(self, iprot):
8255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8257 
      return
8258 
    iprot.readStructBegin()
8259 
    while True:
8260 
      (fname, ftype, fid) = iprot.readFieldBegin()
8261 
      if ftype == TType.STOP:
8262 
        break
8263 
      if fid == 1:
8264 
        if ftype == TType.STRUCT:
8265 
          self.item = Item()
8266 
          self.item.read(iprot)
8267 
        else:
8268 
          iprot.skip(ftype)
8269 
      else:
8270 
        iprot.skip(ftype)
8271 
      iprot.readFieldEnd()
8272 
    iprot.readStructEnd()
8273 
 
8274 
  def write(self, oprot):
8275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8277 
      return
8278 
    oprot.writeStructBegin('addItem_args')
8279 
    if self.item is not None:
8280 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
8281 
      self.item.write(oprot)
8282 
      oprot.writeFieldEnd()
8283 
    oprot.writeFieldStop()
8284 
    oprot.writeStructEnd()
8285 
 
8286 
  def validate(self):
8287 
    return
8288 
 
8289 
 
8290 
  def __repr__(self):
8291 
    L = ['%s=%r' % (key, value)
8292 
      for key, value in self.__dict__.iteritems()]
8293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8294 
 
8295 
  def __eq__(self, other):
8296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8297 
 
8298 
  def __ne__(self, other):
8299 
    return not (self == other)
8300 
 
8301 
class addItem_result:
8302 
  """
8303 
  Attributes:
8304 
   - success
8305 
   - cex
8306 
  """
8307 
 
8308 
  thrift_spec = (
8309 
    (0, TType.I64, 'success', None, None, ), # 0
8310 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8311 
  )
8312 
 
8313 
  def __init__(self, success=None, cex=None,):
8314 
    self.success = success
8315 
    self.cex = cex
8316 
 
8317 
  def read(self, iprot):
8318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8320 
      return
8321 
    iprot.readStructBegin()
8322 
    while True:
8323 
      (fname, ftype, fid) = iprot.readFieldBegin()
8324 
      if ftype == TType.STOP:
8325 
        break
8326 
      if fid == 0:
8327 
        if ftype == TType.I64:
8328 
          self.success = iprot.readI64();
8329 
        else:
8330 
          iprot.skip(ftype)
8331 
      elif fid == 1:
8332 
        if ftype == TType.STRUCT:
8333 
          self.cex = CatalogServiceException()
8334 
          self.cex.read(iprot)
8335 
        else:
8336 
          iprot.skip(ftype)
8337 
      else:
8338 
        iprot.skip(ftype)
8339 
      iprot.readFieldEnd()
8340 
    iprot.readStructEnd()
8341 
 
8342 
  def write(self, oprot):
8343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8345 
      return
8346 
    oprot.writeStructBegin('addItem_result')
8347 
    if self.success is not None:
8348 
      oprot.writeFieldBegin('success', TType.I64, 0)
8349 
      oprot.writeI64(self.success)
8350 
      oprot.writeFieldEnd()
8351 
    if self.cex is not None:
8352 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8353 
      self.cex.write(oprot)
8354 
      oprot.writeFieldEnd()
8355 
    oprot.writeFieldStop()
8356 
    oprot.writeStructEnd()
8357 
 
8358 
  def validate(self):
8359 
    return
8360 
 
8361 
 
8362 
  def __repr__(self):
8363 
    L = ['%s=%r' % (key, value)
8364 
      for key, value in self.__dict__.iteritems()]
8365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8366 
 
8367 
  def __eq__(self, other):
8368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8369 
 
8370 
  def __ne__(self, other):
8371 
    return not (self == other)
8372 
 
8373 
class updateItem_args:
8374 
  """
8375 
  Attributes:
8376 
   - item
8377 
  """
8378 
 
8379 
  thrift_spec = (
8380 
    None, # 0
8381 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
8382 
  )
8383 
 
8384 
  def __init__(self, item=None,):
8385 
    self.item = item
8386 
 
8387 
  def read(self, iprot):
8388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8390 
      return
8391 
    iprot.readStructBegin()
8392 
    while True:
8393 
      (fname, ftype, fid) = iprot.readFieldBegin()
8394 
      if ftype == TType.STOP:
8395 
        break
8396 
      if fid == 1:
8397 
        if ftype == TType.STRUCT:
8398 
          self.item = Item()
8399 
          self.item.read(iprot)
8400 
        else:
8401 
          iprot.skip(ftype)
8402 
      else:
8403 
        iprot.skip(ftype)
8404 
      iprot.readFieldEnd()
8405 
    iprot.readStructEnd()
8406 
 
8407 
  def write(self, oprot):
8408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8410 
      return
8411 
    oprot.writeStructBegin('updateItem_args')
8412 
    if self.item is not None:
8413 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
8414 
      self.item.write(oprot)
8415 
      oprot.writeFieldEnd()
8416 
    oprot.writeFieldStop()
8417 
    oprot.writeStructEnd()
8418 
 
8419 
  def validate(self):
8420 
    return
8421 
 
8422 
 
8423 
  def __repr__(self):
8424 
    L = ['%s=%r' % (key, value)
8425 
      for key, value in self.__dict__.iteritems()]
8426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8427 
 
8428 
  def __eq__(self, other):
8429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8430 
 
8431 
  def __ne__(self, other):
8432 
    return not (self == other)
8433 
 
8434 
class updateItem_result:
8435 
  """
8436 
  Attributes:
8437 
   - success
8438 
   - cex
8439 
  """
8440 
 
8441 
  thrift_spec = (
8442 
    (0, TType.I64, 'success', None, None, ), # 0
8443 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8444 
  )
8445 
 
8446 
  def __init__(self, success=None, cex=None,):
8447 
    self.success = success
8448 
    self.cex = cex
8449 
 
8450 
  def read(self, iprot):
8451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8453 
      return
8454 
    iprot.readStructBegin()
8455 
    while True:
8456 
      (fname, ftype, fid) = iprot.readFieldBegin()
8457 
      if ftype == TType.STOP:
8458 
        break
8459 
      if fid == 0:
8460 
        if ftype == TType.I64:
8461 
          self.success = iprot.readI64();
8462 
        else:
8463 
          iprot.skip(ftype)
8464 
      elif fid == 1:
8465 
        if ftype == TType.STRUCT:
8466 
          self.cex = CatalogServiceException()
8467 
          self.cex.read(iprot)
8468 
        else:
8469 
          iprot.skip(ftype)
8470 
      else:
8471 
        iprot.skip(ftype)
8472 
      iprot.readFieldEnd()
8473 
    iprot.readStructEnd()
8474 
 
8475 
  def write(self, oprot):
8476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8478 
      return
8479 
    oprot.writeStructBegin('updateItem_result')
8480 
    if self.success is not None:
8481 
      oprot.writeFieldBegin('success', TType.I64, 0)
8482 
      oprot.writeI64(self.success)
8483 
      oprot.writeFieldEnd()
8484 
    if self.cex is not None:
8485 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8486 
      self.cex.write(oprot)
8487 
      oprot.writeFieldEnd()
8488 
    oprot.writeFieldStop()
8489 
    oprot.writeStructEnd()
8490 
 
8491 
  def validate(self):
8492 
    return
8493 
 
8494 
 
8495 
  def __repr__(self):
8496 
    L = ['%s=%r' % (key, value)
8497 
      for key, value in self.__dict__.iteritems()]
8498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8499 
 
8500 
  def __eq__(self, other):
8501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8502 
 
8503 
  def __ne__(self, other):
8504 
    return not (self == other)
8505 
 
8506 
class isActive_args:
8507 
  """
8508 
  Attributes:
8509 
   - itemId
8510 
  """
8511 
 
8512 
  thrift_spec = (
8513 
    None, # 0
8514 
    (1, TType.I64, 'itemId', None, None, ), # 1
8515 
  )
8516 
 
8517 
  def __init__(self, itemId=None,):
8518 
    self.itemId = itemId
8519 
 
8520 
  def read(self, iprot):
8521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8523 
      return
8524 
    iprot.readStructBegin()
8525 
    while True:
8526 
      (fname, ftype, fid) = iprot.readFieldBegin()
8527 
      if ftype == TType.STOP:
8528 
        break
8529 
      if fid == 1:
8530 
        if ftype == TType.I64:
8531 
          self.itemId = iprot.readI64();
8532 
        else:
8533 
          iprot.skip(ftype)
8534 
      else:
8535 
        iprot.skip(ftype)
8536 
      iprot.readFieldEnd()
8537 
    iprot.readStructEnd()
8538 
 
8539 
  def write(self, oprot):
8540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8542 
      return
8543 
    oprot.writeStructBegin('isActive_args')
8544 
    if self.itemId is not None:
8545 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8546 
      oprot.writeI64(self.itemId)
8547 
      oprot.writeFieldEnd()
8548 
    oprot.writeFieldStop()
8549 
    oprot.writeStructEnd()
8550 
 
8551 
  def validate(self):
8552 
    return
8553 
 
8554 
 
8555 
  def __repr__(self):
8556 
    L = ['%s=%r' % (key, value)
8557 
      for key, value in self.__dict__.iteritems()]
8558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8559 
 
8560 
  def __eq__(self, other):
8561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8562 
 
8563 
  def __ne__(self, other):
8564 
    return not (self == other)
8565 
 
8566 
class isActive_result:
8567 
  """
8568 
  Attributes:
8569 
   - success
8570 
   - isex
8571 
  """
8572 
 
8573 
  thrift_spec = (
8574 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
8575 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8576 
  )
8577 
 
8578 
  def __init__(self, success=None, isex=None,):
8579 
    self.success = success
8580 
    self.isex = isex
8581 
 
8582 
  def read(self, iprot):
8583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8585 
      return
8586 
    iprot.readStructBegin()
8587 
    while True:
8588 
      (fname, ftype, fid) = iprot.readFieldBegin()
8589 
      if ftype == TType.STOP:
8590 
        break
8591 
      if fid == 0:
8592 
        if ftype == TType.STRUCT:
8593 
          self.success = ItemShippingInfo()
8594 
          self.success.read(iprot)
8595 
        else:
8596 
          iprot.skip(ftype)
8597 
      elif fid == 1:
8598 
        if ftype == TType.STRUCT:
8599 
          self.isex = CatalogServiceException()
8600 
          self.isex.read(iprot)
8601 
        else:
8602 
          iprot.skip(ftype)
8603 
      else:
8604 
        iprot.skip(ftype)
8605 
      iprot.readFieldEnd()
8606 
    iprot.readStructEnd()
8607 
 
8608 
  def write(self, oprot):
8609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8611 
      return
8612 
    oprot.writeStructBegin('isActive_result')
8613 
    if self.success is not None:
8614 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8615 
      self.success.write(oprot)
8616 
      oprot.writeFieldEnd()
8617 
    if self.isex is not None:
8618 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8619 
      self.isex.write(oprot)
8620 
      oprot.writeFieldEnd()
8621 
    oprot.writeFieldStop()
8622 
    oprot.writeStructEnd()
8623 
 
8624 
  def validate(self):
8625 
    return
8626 
 
8627 
 
8628 
  def __repr__(self):
8629 
    L = ['%s=%r' % (key, value)
8630 
      for key, value in self.__dict__.iteritems()]
8631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8632 
 
8633 
  def __eq__(self, other):
8634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8635 
 
8636 
  def __ne__(self, other):
8637 
    return not (self == other)
8638 
 
7438 amit.gupta 8639 
class getItemsStatus_args:
8640 
  """
8641 
  Attributes:
8642 
   - itemIds
8643 
  """
8644 
 
8645 
  thrift_spec = (
8646 
    None, # 0
8647 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
8648 
  )
8649 
 
8650 
  def __init__(self, itemIds=None,):
8651 
    self.itemIds = itemIds
8652 
 
8653 
  def read(self, iprot):
8654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8656 
      return
8657 
    iprot.readStructBegin()
8658 
    while True:
8659 
      (fname, ftype, fid) = iprot.readFieldBegin()
8660 
      if ftype == TType.STOP:
8661 
        break
8662 
      if fid == 1:
8663 
        if ftype == TType.LIST:
8664 
          self.itemIds = []
8590 kshitij.so 8665 
          (_etype33, _size30) = iprot.readListBegin()
8666 
          for _i34 in xrange(_size30):
8667 
            _elem35 = iprot.readI64();
8668 
            self.itemIds.append(_elem35)
7438 amit.gupta 8669 
          iprot.readListEnd()
8670 
        else:
8671 
          iprot.skip(ftype)
8672 
      else:
8673 
        iprot.skip(ftype)
8674 
      iprot.readFieldEnd()
8675 
    iprot.readStructEnd()
8676 
 
8677 
  def write(self, oprot):
8678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8680 
      return
8681 
    oprot.writeStructBegin('getItemsStatus_args')
8682 
    if self.itemIds is not None:
8683 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
8684 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 8685 
      for iter36 in self.itemIds:
8686 
        oprot.writeI64(iter36)
7438 amit.gupta 8687 
      oprot.writeListEnd()
8688 
      oprot.writeFieldEnd()
8689 
    oprot.writeFieldStop()
8690 
    oprot.writeStructEnd()
8691 
 
8692 
  def validate(self):
8693 
    return
8694 
 
8695 
 
8696 
  def __repr__(self):
8697 
    L = ['%s=%r' % (key, value)
8698 
      for key, value in self.__dict__.iteritems()]
8699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8700 
 
8701 
  def __eq__(self, other):
8702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8703 
 
8704 
  def __ne__(self, other):
8705 
    return not (self == other)
8706 
 
8707 
class getItemsStatus_result:
8708 
  """
8709 
  Attributes:
8710 
   - success
8711 
   - isex
8712 
  """
8713 
 
8714 
  thrift_spec = (
8715 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
8716 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8717 
  )
8718 
 
8719 
  def __init__(self, success=None, isex=None,):
8720 
    self.success = success
8721 
    self.isex = isex
8722 
 
8723 
  def read(self, iprot):
8724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8726 
      return
8727 
    iprot.readStructBegin()
8728 
    while True:
8729 
      (fname, ftype, fid) = iprot.readFieldBegin()
8730 
      if ftype == TType.STOP:
8731 
        break
8732 
      if fid == 0:
8733 
        if ftype == TType.MAP:
8734 
          self.success = {}
8590 kshitij.so 8735 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
8736 
          for _i41 in xrange(_size37):
8737 
            _key42 = iprot.readI64();
8738 
            _val43 = iprot.readBool();
8739 
            self.success[_key42] = _val43
7438 amit.gupta 8740 
          iprot.readMapEnd()
8741 
        else:
8742 
          iprot.skip(ftype)
8743 
      elif fid == 1:
8744 
        if ftype == TType.STRUCT:
8745 
          self.isex = CatalogServiceException()
8746 
          self.isex.read(iprot)
8747 
        else:
8748 
          iprot.skip(ftype)
8749 
      else:
8750 
        iprot.skip(ftype)
8751 
      iprot.readFieldEnd()
8752 
    iprot.readStructEnd()
8753 
 
8754 
  def write(self, oprot):
8755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8757 
      return
8758 
    oprot.writeStructBegin('getItemsStatus_result')
8759 
    if self.success is not None:
8760 
      oprot.writeFieldBegin('success', TType.MAP, 0)
8761 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 8762 
      for kiter44,viter45 in self.success.items():
8763 
        oprot.writeI64(kiter44)
8764 
        oprot.writeBool(viter45)
7438 amit.gupta 8765 
      oprot.writeMapEnd()
8766 
      oprot.writeFieldEnd()
8767 
    if self.isex is not None:
8768 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8769 
      self.isex.write(oprot)
8770 
      oprot.writeFieldEnd()
8771 
    oprot.writeFieldStop()
8772 
    oprot.writeStructEnd()
8773 
 
8774 
  def validate(self):
8775 
    return
8776 
 
8777 
 
8778 
  def __repr__(self):
8779 
    L = ['%s=%r' % (key, value)
8780 
      for key, value in self.__dict__.iteritems()]
8781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8782 
 
8783 
  def __eq__(self, other):
8784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8785 
 
8786 
  def __ne__(self, other):
8787 
    return not (self == other)
8788 
 
5944 mandeep.dh 8789 
class getItemStatusDescription_args:
8790 
  """
8791 
  Attributes:
8792 
   - itemId
8793 
  """
8794 
 
8795 
  thrift_spec = (
8796 
    None, # 0
8797 
    (1, TType.I64, 'itemId', None, None, ), # 1
8798 
  )
8799 
 
8800 
  def __init__(self, itemId=None,):
8801 
    self.itemId = itemId
8802 
 
8803 
  def read(self, iprot):
8804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8806 
      return
8807 
    iprot.readStructBegin()
8808 
    while True:
8809 
      (fname, ftype, fid) = iprot.readFieldBegin()
8810 
      if ftype == TType.STOP:
8811 
        break
8812 
      if fid == 1:
8813 
        if ftype == TType.I64:
8814 
          self.itemId = iprot.readI64();
8815 
        else:
8816 
          iprot.skip(ftype)
8817 
      else:
8818 
        iprot.skip(ftype)
8819 
      iprot.readFieldEnd()
8820 
    iprot.readStructEnd()
8821 
 
8822 
  def write(self, oprot):
8823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8825 
      return
8826 
    oprot.writeStructBegin('getItemStatusDescription_args')
8827 
    if self.itemId is not None:
8828 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8829 
      oprot.writeI64(self.itemId)
8830 
      oprot.writeFieldEnd()
8831 
    oprot.writeFieldStop()
8832 
    oprot.writeStructEnd()
8833 
 
8834 
  def validate(self):
8835 
    return
8836 
 
8837 
 
8838 
  def __repr__(self):
8839 
    L = ['%s=%r' % (key, value)
8840 
      for key, value in self.__dict__.iteritems()]
8841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8842 
 
8843 
  def __eq__(self, other):
8844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8845 
 
8846 
  def __ne__(self, other):
8847 
    return not (self == other)
8848 
 
8849 
class getItemStatusDescription_result:
8850 
  """
8851 
  Attributes:
8852 
   - success
8853 
   - isex
8854 
  """
8855 
 
8856 
  thrift_spec = (
8857 
    (0, TType.STRING, 'success', None, None, ), # 0
8858 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8859 
  )
8860 
 
8861 
  def __init__(self, success=None, isex=None,):
8862 
    self.success = success
8863 
    self.isex = isex
8864 
 
8865 
  def read(self, iprot):
8866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8868 
      return
8869 
    iprot.readStructBegin()
8870 
    while True:
8871 
      (fname, ftype, fid) = iprot.readFieldBegin()
8872 
      if ftype == TType.STOP:
8873 
        break
8874 
      if fid == 0:
8875 
        if ftype == TType.STRING:
8876 
          self.success = iprot.readString();
8877 
        else:
8878 
          iprot.skip(ftype)
8879 
      elif fid == 1:
8880 
        if ftype == TType.STRUCT:
8881 
          self.isex = CatalogServiceException()
8882 
          self.isex.read(iprot)
8883 
        else:
8884 
          iprot.skip(ftype)
8885 
      else:
8886 
        iprot.skip(ftype)
8887 
      iprot.readFieldEnd()
8888 
    iprot.readStructEnd()
8889 
 
8890 
  def write(self, oprot):
8891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8893 
      return
8894 
    oprot.writeStructBegin('getItemStatusDescription_result')
8895 
    if self.success is not None:
8896 
      oprot.writeFieldBegin('success', TType.STRING, 0)
8897 
      oprot.writeString(self.success)
8898 
      oprot.writeFieldEnd()
8899 
    if self.isex is not None:
8900 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8901 
      self.isex.write(oprot)
8902 
      oprot.writeFieldEnd()
8903 
    oprot.writeFieldStop()
8904 
    oprot.writeStructEnd()
8905 
 
8906 
  def validate(self):
8907 
    return
8908 
 
8909 
 
8910 
  def __repr__(self):
8911 
    L = ['%s=%r' % (key, value)
8912 
      for key, value in self.__dict__.iteritems()]
8913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8914 
 
8915 
  def __eq__(self, other):
8916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8917 
 
8918 
  def __ne__(self, other):
8919 
    return not (self == other)
8920 
 
8921 
class startItemOn_args:
8922 
  """
8923 
  Attributes:
8924 
   - item_id
8925 
   - timestamp
8926 
  """
8927 
 
8928 
  thrift_spec = (
8929 
    None, # 0
8930 
    (1, TType.I64, 'item_id', None, None, ), # 1
8931 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8932 
  )
8933 
 
8934 
  def __init__(self, item_id=None, timestamp=None,):
8935 
    self.item_id = item_id
8936 
    self.timestamp = timestamp
8937 
 
8938 
  def read(self, iprot):
8939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8941 
      return
8942 
    iprot.readStructBegin()
8943 
    while True:
8944 
      (fname, ftype, fid) = iprot.readFieldBegin()
8945 
      if ftype == TType.STOP:
8946 
        break
8947 
      if fid == 1:
8948 
        if ftype == TType.I64:
8949 
          self.item_id = iprot.readI64();
8950 
        else:
8951 
          iprot.skip(ftype)
8952 
      elif fid == 2:
8953 
        if ftype == TType.I64:
8954 
          self.timestamp = iprot.readI64();
8955 
        else:
8956 
          iprot.skip(ftype)
8957 
      else:
8958 
        iprot.skip(ftype)
8959 
      iprot.readFieldEnd()
8960 
    iprot.readStructEnd()
8961 
 
8962 
  def write(self, oprot):
8963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8965 
      return
8966 
    oprot.writeStructBegin('startItemOn_args')
8967 
    if self.item_id is not None:
8968 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8969 
      oprot.writeI64(self.item_id)
8970 
      oprot.writeFieldEnd()
8971 
    if self.timestamp is not None:
8972 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8973 
      oprot.writeI64(self.timestamp)
8974 
      oprot.writeFieldEnd()
8975 
    oprot.writeFieldStop()
8976 
    oprot.writeStructEnd()
8977 
 
8978 
  def validate(self):
8979 
    return
8980 
 
8981 
 
8982 
  def __repr__(self):
8983 
    L = ['%s=%r' % (key, value)
8984 
      for key, value in self.__dict__.iteritems()]
8985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8986 
 
8987 
  def __eq__(self, other):
8988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8989 
 
8990 
  def __ne__(self, other):
8991 
    return not (self == other)
8992 
 
8993 
class startItemOn_result:
8994 
  """
8995 
  Attributes:
8996 
   - cex
8997 
  """
8998 
 
8999 
  thrift_spec = (
9000 
    None, # 0
9001 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9002 
  )
9003 
 
9004 
  def __init__(self, cex=None,):
9005 
    self.cex = cex
9006 
 
9007 
  def read(self, iprot):
9008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9010 
      return
9011 
    iprot.readStructBegin()
9012 
    while True:
9013 
      (fname, ftype, fid) = iprot.readFieldBegin()
9014 
      if ftype == TType.STOP:
9015 
        break
9016 
      if fid == 1:
9017 
        if ftype == TType.STRUCT:
9018 
          self.cex = CatalogServiceException()
9019 
          self.cex.read(iprot)
9020 
        else:
9021 
          iprot.skip(ftype)
9022 
      else:
9023 
        iprot.skip(ftype)
9024 
      iprot.readFieldEnd()
9025 
    iprot.readStructEnd()
9026 
 
9027 
  def write(self, oprot):
9028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9030 
      return
9031 
    oprot.writeStructBegin('startItemOn_result')
9032 
    if self.cex is not None:
9033 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9034 
      self.cex.write(oprot)
9035 
      oprot.writeFieldEnd()
9036 
    oprot.writeFieldStop()
9037 
    oprot.writeStructEnd()
9038 
 
9039 
  def validate(self):
9040 
    return
9041 
 
9042 
 
9043 
  def __repr__(self):
9044 
    L = ['%s=%r' % (key, value)
9045 
      for key, value in self.__dict__.iteritems()]
9046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9047 
 
9048 
  def __eq__(self, other):
9049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9050 
 
9051 
  def __ne__(self, other):
9052 
    return not (self == other)
9053 
 
9054 
class retireItemOn_args:
9055 
  """
9056 
  Attributes:
9057 
   - item_id
9058 
   - timestamp
9059 
  """
9060 
 
9061 
  thrift_spec = (
9062 
    None, # 0
9063 
    (1, TType.I64, 'item_id', None, None, ), # 1
9064 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9065 
  )
9066 
 
9067 
  def __init__(self, item_id=None, timestamp=None,):
9068 
    self.item_id = item_id
9069 
    self.timestamp = timestamp
9070 
 
9071 
  def read(self, iprot):
9072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9074 
      return
9075 
    iprot.readStructBegin()
9076 
    while True:
9077 
      (fname, ftype, fid) = iprot.readFieldBegin()
9078 
      if ftype == TType.STOP:
9079 
        break
9080 
      if fid == 1:
9081 
        if ftype == TType.I64:
9082 
          self.item_id = iprot.readI64();
9083 
        else:
9084 
          iprot.skip(ftype)
9085 
      elif fid == 2:
9086 
        if ftype == TType.I64:
9087 
          self.timestamp = iprot.readI64();
9088 
        else:
9089 
          iprot.skip(ftype)
9090 
      else:
9091 
        iprot.skip(ftype)
9092 
      iprot.readFieldEnd()
9093 
    iprot.readStructEnd()
9094 
 
9095 
  def write(self, oprot):
9096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9098 
      return
9099 
    oprot.writeStructBegin('retireItemOn_args')
9100 
    if self.item_id is not None:
9101 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9102 
      oprot.writeI64(self.item_id)
9103 
      oprot.writeFieldEnd()
9104 
    if self.timestamp is not None:
9105 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
9106 
      oprot.writeI64(self.timestamp)
9107 
      oprot.writeFieldEnd()
9108 
    oprot.writeFieldStop()
9109 
    oprot.writeStructEnd()
9110 
 
9111 
  def validate(self):
9112 
    return
9113 
 
9114 
 
9115 
  def __repr__(self):
9116 
    L = ['%s=%r' % (key, value)
9117 
      for key, value in self.__dict__.iteritems()]
9118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9119 
 
9120 
  def __eq__(self, other):
9121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9122 
 
9123 
  def __ne__(self, other):
9124 
    return not (self == other)
9125 
 
9126 
class retireItemOn_result:
9127 
  """
9128 
  Attributes:
9129 
   - cex
9130 
  """
9131 
 
9132 
  thrift_spec = (
9133 
    None, # 0
9134 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9135 
  )
9136 
 
9137 
  def __init__(self, cex=None,):
9138 
    self.cex = cex
9139 
 
9140 
  def read(self, iprot):
9141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9143 
      return
9144 
    iprot.readStructBegin()
9145 
    while True:
9146 
      (fname, ftype, fid) = iprot.readFieldBegin()
9147 
      if ftype == TType.STOP:
9148 
        break
9149 
      if fid == 1:
9150 
        if ftype == TType.STRUCT:
9151 
          self.cex = CatalogServiceException()
9152 
          self.cex.read(iprot)
9153 
        else:
9154 
          iprot.skip(ftype)
9155 
      else:
9156 
        iprot.skip(ftype)
9157 
      iprot.readFieldEnd()
9158 
    iprot.readStructEnd()
9159 
 
9160 
  def write(self, oprot):
9161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9163 
      return
9164 
    oprot.writeStructBegin('retireItemOn_result')
9165 
    if self.cex is not None:
9166 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9167 
      self.cex.write(oprot)
9168 
      oprot.writeFieldEnd()
9169 
    oprot.writeFieldStop()
9170 
    oprot.writeStructEnd()
9171 
 
9172 
  def validate(self):
9173 
    return
9174 
 
9175 
 
9176 
  def __repr__(self):
9177 
    L = ['%s=%r' % (key, value)
9178 
      for key, value in self.__dict__.iteritems()]
9179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9180 
 
9181 
  def __eq__(self, other):
9182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9183 
 
9184 
  def __ne__(self, other):
9185 
    return not (self == other)
9186 
 
9187 
class changeItemStatus_args:
9188 
  """
9189 
  Attributes:
9190 
   - item_id
9191 
   - timestamp
9192 
   - newstatus
9193 
  """
9194 
 
9195 
  thrift_spec = (
9196 
    None, # 0
9197 
    (1, TType.I64, 'item_id', None, None, ), # 1
9198 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9199 
    (3, TType.I32, 'newstatus', None, None, ), # 3
9200 
  )
9201 
 
9202 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
9203 
    self.item_id = item_id
9204 
    self.timestamp = timestamp
9205 
    self.newstatus = newstatus
9206 
 
9207 
  def read(self, iprot):
9208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9210 
      return
9211 
    iprot.readStructBegin()
9212 
    while True:
9213 
      (fname, ftype, fid) = iprot.readFieldBegin()
9214 
      if ftype == TType.STOP:
9215 
        break
9216 
      if fid == 1:
9217 
        if ftype == TType.I64:
9218 
          self.item_id = iprot.readI64();
9219 
        else:
9220 
          iprot.skip(ftype)
9221 
      elif fid == 2:
9222 
        if ftype == TType.I64:
9223 
          self.timestamp = iprot.readI64();
9224 
        else:
9225 
          iprot.skip(ftype)
9226 
      elif fid == 3:
9227 
        if ftype == TType.I32:
9228 
          self.newstatus = iprot.readI32();
9229 
        else:
9230 
          iprot.skip(ftype)
9231 
      else:
9232 
        iprot.skip(ftype)
9233 
      iprot.readFieldEnd()
9234 
    iprot.readStructEnd()
9235 
 
9236 
  def write(self, oprot):
9237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9239 
      return
9240 
    oprot.writeStructBegin('changeItemStatus_args')
9241 
    if self.item_id is not None:
9242 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9243 
      oprot.writeI64(self.item_id)
9244 
      oprot.writeFieldEnd()
9245 
    if self.timestamp is not None:
9246 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
9247 
      oprot.writeI64(self.timestamp)
9248 
      oprot.writeFieldEnd()
9249 
    if self.newstatus is not None:
9250 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
9251 
      oprot.writeI32(self.newstatus)
9252 
      oprot.writeFieldEnd()
9253 
    oprot.writeFieldStop()
9254 
    oprot.writeStructEnd()
9255 
 
9256 
  def validate(self):
9257 
    return
9258 
 
9259 
 
9260 
  def __repr__(self):
9261 
    L = ['%s=%r' % (key, value)
9262 
      for key, value in self.__dict__.iteritems()]
9263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9264 
 
9265 
  def __eq__(self, other):
9266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9267 
 
9268 
  def __ne__(self, other):
9269 
    return not (self == other)
9270 
 
9271 
class changeItemStatus_result:
9272 
  """
9273 
  Attributes:
9274 
   - cex
9275 
  """
9276 
 
9277 
  thrift_spec = (
9278 
    None, # 0
9279 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9280 
  )
9281 
 
9282 
  def __init__(self, cex=None,):
9283 
    self.cex = cex
9284 
 
9285 
  def read(self, iprot):
9286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9288 
      return
9289 
    iprot.readStructBegin()
9290 
    while True:
9291 
      (fname, ftype, fid) = iprot.readFieldBegin()
9292 
      if ftype == TType.STOP:
9293 
        break
9294 
      if fid == 1:
9295 
        if ftype == TType.STRUCT:
9296 
          self.cex = CatalogServiceException()
9297 
          self.cex.read(iprot)
9298 
        else:
9299 
          iprot.skip(ftype)
9300 
      else:
9301 
        iprot.skip(ftype)
9302 
      iprot.readFieldEnd()
9303 
    iprot.readStructEnd()
9304 
 
9305 
  def write(self, oprot):
9306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9308 
      return
9309 
    oprot.writeStructBegin('changeItemStatus_result')
9310 
    if self.cex is not None:
9311 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9312 
      self.cex.write(oprot)
9313 
      oprot.writeFieldEnd()
9314 
    oprot.writeFieldStop()
9315 
    oprot.writeStructEnd()
9316 
 
9317 
  def validate(self):
9318 
    return
9319 
 
9320 
 
9321 
  def __repr__(self):
9322 
    L = ['%s=%r' % (key, value)
9323 
      for key, value in self.__dict__.iteritems()]
9324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9325 
 
9326 
  def __eq__(self, other):
9327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9328 
 
9329 
  def __ne__(self, other):
9330 
    return not (self == other)
9331 
 
9332 
class getItem_args:
9333 
  """
9334 
  Attributes:
9335 
   - item_id
9336 
  """
9337 
 
9338 
  thrift_spec = (
9339 
    None, # 0
9340 
    (1, TType.I64, 'item_id', None, None, ), # 1
9341 
  )
9342 
 
9343 
  def __init__(self, item_id=None,):
9344 
    self.item_id = item_id
9345 
 
9346 
  def read(self, iprot):
9347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9349 
      return
9350 
    iprot.readStructBegin()
9351 
    while True:
9352 
      (fname, ftype, fid) = iprot.readFieldBegin()
9353 
      if ftype == TType.STOP:
9354 
        break
9355 
      if fid == 1:
9356 
        if ftype == TType.I64:
9357 
          self.item_id = iprot.readI64();
9358 
        else:
9359 
          iprot.skip(ftype)
9360 
      else:
9361 
        iprot.skip(ftype)
9362 
      iprot.readFieldEnd()
9363 
    iprot.readStructEnd()
9364 
 
9365 
  def write(self, oprot):
9366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9368 
      return
9369 
    oprot.writeStructBegin('getItem_args')
9370 
    if self.item_id is not None:
9371 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9372 
      oprot.writeI64(self.item_id)
9373 
      oprot.writeFieldEnd()
9374 
    oprot.writeFieldStop()
9375 
    oprot.writeStructEnd()
9376 
 
9377 
  def validate(self):
9378 
    return
9379 
 
9380 
 
9381 
  def __repr__(self):
9382 
    L = ['%s=%r' % (key, value)
9383 
      for key, value in self.__dict__.iteritems()]
9384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9385 
 
9386 
  def __eq__(self, other):
9387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9388 
 
9389 
  def __ne__(self, other):
9390 
    return not (self == other)
9391 
 
9392 
class getItem_result:
9393 
  """
9394 
  Attributes:
9395 
   - success
9396 
   - cex
9397 
  """
9398 
 
9399 
  thrift_spec = (
9400 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9401 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9402 
  )
9403 
 
9404 
  def __init__(self, success=None, cex=None,):
9405 
    self.success = success
9406 
    self.cex = cex
9407 
 
9408 
  def read(self, iprot):
9409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9411 
      return
9412 
    iprot.readStructBegin()
9413 
    while True:
9414 
      (fname, ftype, fid) = iprot.readFieldBegin()
9415 
      if ftype == TType.STOP:
9416 
        break
9417 
      if fid == 0:
9418 
        if ftype == TType.STRUCT:
9419 
          self.success = Item()
9420 
          self.success.read(iprot)
9421 
        else:
9422 
          iprot.skip(ftype)
9423 
      elif fid == 1:
9424 
        if ftype == TType.STRUCT:
9425 
          self.cex = CatalogServiceException()
9426 
          self.cex.read(iprot)
9427 
        else:
9428 
          iprot.skip(ftype)
9429 
      else:
9430 
        iprot.skip(ftype)
9431 
      iprot.readFieldEnd()
9432 
    iprot.readStructEnd()
9433 
 
9434 
  def write(self, oprot):
9435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9437 
      return
9438 
    oprot.writeStructBegin('getItem_result')
9439 
    if self.success is not None:
9440 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9441 
      self.success.write(oprot)
9442 
      oprot.writeFieldEnd()
9443 
    if self.cex is not None:
9444 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9445 
      self.cex.write(oprot)
9446 
      oprot.writeFieldEnd()
9447 
    oprot.writeFieldStop()
9448 
    oprot.writeStructEnd()
9449 
 
9450 
  def validate(self):
9451 
    return
9452 
 
9453 
 
9454 
  def __repr__(self):
9455 
    L = ['%s=%r' % (key, value)
9456 
      for key, value in self.__dict__.iteritems()]
9457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9458 
 
9459 
  def __eq__(self, other):
9460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9461 
 
9462 
  def __ne__(self, other):
9463 
    return not (self == other)
9464 
 
9465 
class getItemsByCatalogId_args:
9466 
  """
9467 
  Attributes:
9468 
   - catalog_item_id
9469 
  """
9470 
 
9471 
  thrift_spec = (
9472 
    None, # 0
9473 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
9474 
  )
9475 
 
9476 
  def __init__(self, catalog_item_id=None,):
9477 
    self.catalog_item_id = catalog_item_id
9478 
 
9479 
  def read(self, iprot):
9480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9482 
      return
9483 
    iprot.readStructBegin()
9484 
    while True:
9485 
      (fname, ftype, fid) = iprot.readFieldBegin()
9486 
      if ftype == TType.STOP:
9487 
        break
9488 
      if fid == 1:
9489 
        if ftype == TType.I64:
9490 
          self.catalog_item_id = iprot.readI64();
9491 
        else:
9492 
          iprot.skip(ftype)
9493 
      else:
9494 
        iprot.skip(ftype)
9495 
      iprot.readFieldEnd()
9496 
    iprot.readStructEnd()
9497 
 
9498 
  def write(self, oprot):
9499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9501 
      return
9502 
    oprot.writeStructBegin('getItemsByCatalogId_args')
9503 
    if self.catalog_item_id is not None:
9504 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
9505 
      oprot.writeI64(self.catalog_item_id)
9506 
      oprot.writeFieldEnd()
9507 
    oprot.writeFieldStop()
9508 
    oprot.writeStructEnd()
9509 
 
9510 
  def validate(self):
9511 
    return
9512 
 
9513 
 
9514 
  def __repr__(self):
9515 
    L = ['%s=%r' % (key, value)
9516 
      for key, value in self.__dict__.iteritems()]
9517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9518 
 
9519 
  def __eq__(self, other):
9520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9521 
 
9522 
  def __ne__(self, other):
9523 
    return not (self == other)
9524 
 
9525 
class getItemsByCatalogId_result:
9526 
  """
9527 
  Attributes:
9528 
   - success
9529 
   - cex
9530 
  """
9531 
 
9532 
  thrift_spec = (
9533 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9534 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9535 
  )
9536 
 
9537 
  def __init__(self, success=None, cex=None,):
9538 
    self.success = success
9539 
    self.cex = cex
9540 
 
9541 
  def read(self, iprot):
9542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9544 
      return
9545 
    iprot.readStructBegin()
9546 
    while True:
9547 
      (fname, ftype, fid) = iprot.readFieldBegin()
9548 
      if ftype == TType.STOP:
9549 
        break
9550 
      if fid == 0:
9551 
        if ftype == TType.LIST:
9552 
          self.success = []
8590 kshitij.so 9553 
          (_etype49, _size46) = iprot.readListBegin()
9554 
          for _i50 in xrange(_size46):
9555 
            _elem51 = Item()
9556 
            _elem51.read(iprot)
9557 
            self.success.append(_elem51)
5944 mandeep.dh 9558 
          iprot.readListEnd()
9559 
        else:
9560 
          iprot.skip(ftype)
9561 
      elif fid == 1:
9562 
        if ftype == TType.STRUCT:
9563 
          self.cex = CatalogServiceException()
9564 
          self.cex.read(iprot)
9565 
        else:
9566 
          iprot.skip(ftype)
9567 
      else:
9568 
        iprot.skip(ftype)
9569 
      iprot.readFieldEnd()
9570 
    iprot.readStructEnd()
9571 
 
9572 
  def write(self, oprot):
9573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9575 
      return
9576 
    oprot.writeStructBegin('getItemsByCatalogId_result')
9577 
    if self.success is not None:
9578 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9579 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9580 
      for iter52 in self.success:
9581 
        iter52.write(oprot)
5944 mandeep.dh 9582 
      oprot.writeListEnd()
9583 
      oprot.writeFieldEnd()
9584 
    if self.cex is not None:
9585 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9586 
      self.cex.write(oprot)
9587 
      oprot.writeFieldEnd()
9588 
    oprot.writeFieldStop()
9589 
    oprot.writeStructEnd()
9590 
 
9591 
  def validate(self):
9592 
    return
9593 
 
9594 
 
9595 
  def __repr__(self):
9596 
    L = ['%s=%r' % (key, value)
9597 
      for key, value in self.__dict__.iteritems()]
9598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9599 
 
9600 
  def __eq__(self, other):
9601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9602 
 
9603 
  def __ne__(self, other):
9604 
    return not (self == other)
9605 
 
9606 
class getValidItemsByCatalogId_args:
9607 
  """
9608 
  Attributes:
9609 
   - catalog_item_id
9610 
  """
9611 
 
9612 
  thrift_spec = (
9613 
    None, # 0
9614 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
9615 
  )
9616 
 
9617 
  def __init__(self, catalog_item_id=None,):
9618 
    self.catalog_item_id = catalog_item_id
9619 
 
9620 
  def read(self, iprot):
9621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9623 
      return
9624 
    iprot.readStructBegin()
9625 
    while True:
9626 
      (fname, ftype, fid) = iprot.readFieldBegin()
9627 
      if ftype == TType.STOP:
9628 
        break
9629 
      if fid == 1:
9630 
        if ftype == TType.I64:
9631 
          self.catalog_item_id = iprot.readI64();
9632 
        else:
9633 
          iprot.skip(ftype)
9634 
      else:
9635 
        iprot.skip(ftype)
9636 
      iprot.readFieldEnd()
9637 
    iprot.readStructEnd()
9638 
 
9639 
  def write(self, oprot):
9640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9642 
      return
9643 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
9644 
    if self.catalog_item_id is not None:
9645 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
9646 
      oprot.writeI64(self.catalog_item_id)
9647 
      oprot.writeFieldEnd()
9648 
    oprot.writeFieldStop()
9649 
    oprot.writeStructEnd()
9650 
 
9651 
  def validate(self):
9652 
    return
9653 
 
9654 
 
9655 
  def __repr__(self):
9656 
    L = ['%s=%r' % (key, value)
9657 
      for key, value in self.__dict__.iteritems()]
9658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9659 
 
9660 
  def __eq__(self, other):
9661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9662 
 
9663 
  def __ne__(self, other):
9664 
    return not (self == other)
9665 
 
9666 
class getValidItemsByCatalogId_result:
9667 
  """
9668 
  Attributes:
9669 
   - success
9670 
   - cex
9671 
  """
9672 
 
9673 
  thrift_spec = (
9674 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9675 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9676 
  )
9677 
 
9678 
  def __init__(self, success=None, cex=None,):
9679 
    self.success = success
9680 
    self.cex = cex
9681 
 
9682 
  def read(self, iprot):
9683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9685 
      return
9686 
    iprot.readStructBegin()
9687 
    while True:
9688 
      (fname, ftype, fid) = iprot.readFieldBegin()
9689 
      if ftype == TType.STOP:
9690 
        break
9691 
      if fid == 0:
9692 
        if ftype == TType.LIST:
9693 
          self.success = []
8590 kshitij.so 9694 
          (_etype56, _size53) = iprot.readListBegin()
9695 
          for _i57 in xrange(_size53):
9696 
            _elem58 = Item()
9697 
            _elem58.read(iprot)
9698 
            self.success.append(_elem58)
5944 mandeep.dh 9699 
          iprot.readListEnd()
9700 
        else:
9701 
          iprot.skip(ftype)
9702 
      elif fid == 1:
9703 
        if ftype == TType.STRUCT:
9704 
          self.cex = CatalogServiceException()
9705 
          self.cex.read(iprot)
9706 
        else:
9707 
          iprot.skip(ftype)
9708 
      else:
9709 
        iprot.skip(ftype)
9710 
      iprot.readFieldEnd()
9711 
    iprot.readStructEnd()
9712 
 
9713 
  def write(self, oprot):
9714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9716 
      return
9717 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
9718 
    if self.success is not None:
9719 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9720 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9721 
      for iter59 in self.success:
9722 
        iter59.write(oprot)
5944 mandeep.dh 9723 
      oprot.writeListEnd()
9724 
      oprot.writeFieldEnd()
9725 
    if self.cex is not None:
9726 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9727 
      self.cex.write(oprot)
9728 
      oprot.writeFieldEnd()
9729 
    oprot.writeFieldStop()
9730 
    oprot.writeStructEnd()
9731 
 
9732 
  def validate(self):
9733 
    return
9734 
 
9735 
 
9736 
  def __repr__(self):
9737 
    L = ['%s=%r' % (key, value)
9738 
      for key, value in self.__dict__.iteritems()]
9739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9740 
 
9741 
  def __eq__(self, other):
9742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9743 
 
9744 
  def __ne__(self, other):
9745 
    return not (self == other)
9746 
 
9747 
class getAllItems_args:
9748 
  """
9749 
  Attributes:
9750 
   - isActive
9751 
  """
9752 
 
9753 
  thrift_spec = (
9754 
    None, # 0
9755 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
9756 
  )
9757 
 
9758 
  def __init__(self, isActive=None,):
9759 
    self.isActive = isActive
9760 
 
9761 
  def read(self, iprot):
9762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9764 
      return
9765 
    iprot.readStructBegin()
9766 
    while True:
9767 
      (fname, ftype, fid) = iprot.readFieldBegin()
9768 
      if ftype == TType.STOP:
9769 
        break
9770 
      if fid == 1:
9771 
        if ftype == TType.BOOL:
9772 
          self.isActive = iprot.readBool();
9773 
        else:
9774 
          iprot.skip(ftype)
9775 
      else:
9776 
        iprot.skip(ftype)
9777 
      iprot.readFieldEnd()
9778 
    iprot.readStructEnd()
9779 
 
9780 
  def write(self, oprot):
9781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9783 
      return
9784 
    oprot.writeStructBegin('getAllItems_args')
9785 
    if self.isActive is not None:
9786 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
9787 
      oprot.writeBool(self.isActive)
9788 
      oprot.writeFieldEnd()
9789 
    oprot.writeFieldStop()
9790 
    oprot.writeStructEnd()
9791 
 
9792 
  def validate(self):
9793 
    return
9794 
 
9795 
 
9796 
  def __repr__(self):
9797 
    L = ['%s=%r' % (key, value)
9798 
      for key, value in self.__dict__.iteritems()]
9799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9800 
 
9801 
  def __eq__(self, other):
9802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9803 
 
9804 
  def __ne__(self, other):
9805 
    return not (self == other)
9806 
 
9807 
class getAllItems_result:
9808 
  """
9809 
  Attributes:
9810 
   - success
9811 
   - cex
9812 
  """
9813 
 
9814 
  thrift_spec = (
9815 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9816 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9817 
  )
9818 
 
9819 
  def __init__(self, success=None, cex=None,):
9820 
    self.success = success
9821 
    self.cex = cex
9822 
 
9823 
  def read(self, iprot):
9824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9826 
      return
9827 
    iprot.readStructBegin()
9828 
    while True:
9829 
      (fname, ftype, fid) = iprot.readFieldBegin()
9830 
      if ftype == TType.STOP:
9831 
        break
9832 
      if fid == 0:
9833 
        if ftype == TType.LIST:
9834 
          self.success = []
8590 kshitij.so 9835 
          (_etype63, _size60) = iprot.readListBegin()
9836 
          for _i64 in xrange(_size60):
9837 
            _elem65 = Item()
9838 
            _elem65.read(iprot)
9839 
            self.success.append(_elem65)
5944 mandeep.dh 9840 
          iprot.readListEnd()
9841 
        else:
9842 
          iprot.skip(ftype)
9843 
      elif fid == 1:
9844 
        if ftype == TType.STRUCT:
9845 
          self.cex = CatalogServiceException()
9846 
          self.cex.read(iprot)
9847 
        else:
9848 
          iprot.skip(ftype)
9849 
      else:
9850 
        iprot.skip(ftype)
9851 
      iprot.readFieldEnd()
9852 
    iprot.readStructEnd()
9853 
 
9854 
  def write(self, oprot):
9855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9857 
      return
9858 
    oprot.writeStructBegin('getAllItems_result')
9859 
    if self.success is not None:
9860 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9861 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9862 
      for iter66 in self.success:
9863 
        iter66.write(oprot)
5944 mandeep.dh 9864 
      oprot.writeListEnd()
9865 
      oprot.writeFieldEnd()
9866 
    if self.cex is not None:
9867 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9868 
      self.cex.write(oprot)
9869 
      oprot.writeFieldEnd()
9870 
    oprot.writeFieldStop()
9871 
    oprot.writeStructEnd()
9872 
 
9873 
  def validate(self):
9874 
    return
9875 
 
9876 
 
9877 
  def __repr__(self):
9878 
    L = ['%s=%r' % (key, value)
9879 
      for key, value in self.__dict__.iteritems()]
9880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9881 
 
9882 
  def __eq__(self, other):
9883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9884 
 
9885 
  def __ne__(self, other):
9886 
    return not (self == other)
9887 
 
9888 
class getAllItemsByStatus_args:
9889 
  """
9890 
  Attributes:
9891 
   - itemStatus
9892 
  """
9893 
 
9894 
  thrift_spec = (
9895 
    None, # 0
9896 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9897 
  )
9898 
 
9899 
  def __init__(self, itemStatus=None,):
9900 
    self.itemStatus = itemStatus
9901 
 
9902 
  def read(self, iprot):
9903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9905 
      return
9906 
    iprot.readStructBegin()
9907 
    while True:
9908 
      (fname, ftype, fid) = iprot.readFieldBegin()
9909 
      if ftype == TType.STOP:
9910 
        break
9911 
      if fid == 1:
9912 
        if ftype == TType.I32:
9913 
          self.itemStatus = iprot.readI32();
9914 
        else:
9915 
          iprot.skip(ftype)
9916 
      else:
9917 
        iprot.skip(ftype)
9918 
      iprot.readFieldEnd()
9919 
    iprot.readStructEnd()
9920 
 
9921 
  def write(self, oprot):
9922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9924 
      return
9925 
    oprot.writeStructBegin('getAllItemsByStatus_args')
9926 
    if self.itemStatus is not None:
9927 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9928 
      oprot.writeI32(self.itemStatus)
9929 
      oprot.writeFieldEnd()
9930 
    oprot.writeFieldStop()
9931 
    oprot.writeStructEnd()
9932 
 
9933 
  def validate(self):
9934 
    return
9935 
 
9936 
 
9937 
  def __repr__(self):
9938 
    L = ['%s=%r' % (key, value)
9939 
      for key, value in self.__dict__.iteritems()]
9940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9941 
 
9942 
  def __eq__(self, other):
9943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9944 
 
9945 
  def __ne__(self, other):
9946 
    return not (self == other)
9947 
 
9948 
class getAllItemsByStatus_result:
9949 
  """
9950 
  Attributes:
9951 
   - success
9952 
   - cex
9953 
  """
9954 
 
9955 
  thrift_spec = (
9956 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9957 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9958 
  )
9959 
 
9960 
  def __init__(self, success=None, cex=None,):
9961 
    self.success = success
9962 
    self.cex = cex
9963 
 
9964 
  def read(self, iprot):
9965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9967 
      return
9968 
    iprot.readStructBegin()
9969 
    while True:
9970 
      (fname, ftype, fid) = iprot.readFieldBegin()
9971 
      if ftype == TType.STOP:
9972 
        break
9973 
      if fid == 0:
9974 
        if ftype == TType.LIST:
9975 
          self.success = []
8590 kshitij.so 9976 
          (_etype70, _size67) = iprot.readListBegin()
9977 
          for _i71 in xrange(_size67):
9978 
            _elem72 = Item()
9979 
            _elem72.read(iprot)
9980 
            self.success.append(_elem72)
5944 mandeep.dh 9981 
          iprot.readListEnd()
9982 
        else:
9983 
          iprot.skip(ftype)
9984 
      elif fid == 1:
9985 
        if ftype == TType.STRUCT:
9986 
          self.cex = CatalogServiceException()
9987 
          self.cex.read(iprot)
9988 
        else:
9989 
          iprot.skip(ftype)
9990 
      else:
9991 
        iprot.skip(ftype)
9992 
      iprot.readFieldEnd()
9993 
    iprot.readStructEnd()
9994 
 
9995 
  def write(self, oprot):
9996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9998 
      return
9999 
    oprot.writeStructBegin('getAllItemsByStatus_result')
10000 
    if self.success is not None:
10001 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10002 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10003 
      for iter73 in self.success:
10004 
        iter73.write(oprot)
5944 mandeep.dh 10005 
      oprot.writeListEnd()
10006 
      oprot.writeFieldEnd()
10007 
    if self.cex is not None:
10008 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10009 
      self.cex.write(oprot)
10010 
      oprot.writeFieldEnd()
10011 
    oprot.writeFieldStop()
10012 
    oprot.writeStructEnd()
10013 
 
10014 
  def validate(self):
10015 
    return
10016 
 
10017 
 
10018 
  def __repr__(self):
10019 
    L = ['%s=%r' % (key, value)
10020 
      for key, value in self.__dict__.iteritems()]
10021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10022 
 
10023 
  def __eq__(self, other):
10024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10025 
 
10026 
  def __ne__(self, other):
10027 
    return not (self == other)
10028 
 
10029 
class markItemAsContentComplete_args:
10030 
  """
10031 
  Attributes:
10032 
   - entityId
10033 
   - category
10034 
   - brand
10035 
   - modelName
10036 
   - modelNumber
9253 rajveer 10037 
   - isAndroid
5944 mandeep.dh 10038 
  """
10039 
 
10040 
  thrift_spec = (
10041 
    None, # 0
10042 
    (1, TType.I64, 'entityId', None, None, ), # 1
10043 
    (2, TType.I64, 'category', None, None, ), # 2
10044 
    (3, TType.STRING, 'brand', None, None, ), # 3
10045 
    (4, TType.STRING, 'modelName', None, None, ), # 4
10046 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 10047 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 10048 
  )
10049 
 
9253 rajveer 10050 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 10051 
    self.entityId = entityId
10052 
    self.category = category
10053 
    self.brand = brand
10054 
    self.modelName = modelName
10055 
    self.modelNumber = modelNumber
9253 rajveer 10056 
    self.isAndroid = isAndroid
5944 mandeep.dh 10057 
 
10058 
  def read(self, iprot):
10059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10061 
      return
10062 
    iprot.readStructBegin()
10063 
    while True:
10064 
      (fname, ftype, fid) = iprot.readFieldBegin()
10065 
      if ftype == TType.STOP:
10066 
        break
10067 
      if fid == 1:
10068 
        if ftype == TType.I64:
10069 
          self.entityId = iprot.readI64();
10070 
        else:
10071 
          iprot.skip(ftype)
10072 
      elif fid == 2:
10073 
        if ftype == TType.I64:
10074 
          self.category = iprot.readI64();
10075 
        else:
10076 
          iprot.skip(ftype)
10077 
      elif fid == 3:
10078 
        if ftype == TType.STRING:
10079 
          self.brand = iprot.readString();
10080 
        else:
10081 
          iprot.skip(ftype)
10082 
      elif fid == 4:
10083 
        if ftype == TType.STRING:
10084 
          self.modelName = iprot.readString();
10085 
        else:
10086 
          iprot.skip(ftype)
10087 
      elif fid == 5:
10088 
        if ftype == TType.STRING:
10089 
          self.modelNumber = iprot.readString();
10090 
        else:
10091 
          iprot.skip(ftype)
9253 rajveer 10092 
      elif fid == 6:
10093 
        if ftype == TType.BOOL:
10094 
          self.isAndroid = iprot.readBool();
10095 
        else:
10096 
          iprot.skip(ftype)
5944 mandeep.dh 10097 
      else:
10098 
        iprot.skip(ftype)
10099 
      iprot.readFieldEnd()
10100 
    iprot.readStructEnd()
10101 
 
10102 
  def write(self, oprot):
10103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10105 
      return
10106 
    oprot.writeStructBegin('markItemAsContentComplete_args')
10107 
    if self.entityId is not None:
10108 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
10109 
      oprot.writeI64(self.entityId)
10110 
      oprot.writeFieldEnd()
10111 
    if self.category is not None:
10112 
      oprot.writeFieldBegin('category', TType.I64, 2)
10113 
      oprot.writeI64(self.category)
10114 
      oprot.writeFieldEnd()
10115 
    if self.brand is not None:
10116 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10117 
      oprot.writeString(self.brand)
10118 
      oprot.writeFieldEnd()
10119 
    if self.modelName is not None:
10120 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
10121 
      oprot.writeString(self.modelName)
10122 
      oprot.writeFieldEnd()
10123 
    if self.modelNumber is not None:
10124 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
10125 
      oprot.writeString(self.modelNumber)
10126 
      oprot.writeFieldEnd()
9253 rajveer 10127 
    if self.isAndroid is not None:
10128 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
10129 
      oprot.writeBool(self.isAndroid)
10130 
      oprot.writeFieldEnd()
5944 mandeep.dh 10131 
    oprot.writeFieldStop()
10132 
    oprot.writeStructEnd()
10133 
 
10134 
  def validate(self):
10135 
    return
10136 
 
10137 
 
10138 
  def __repr__(self):
10139 
    L = ['%s=%r' % (key, value)
10140 
      for key, value in self.__dict__.iteritems()]
10141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10142 
 
10143 
  def __eq__(self, other):
10144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10145 
 
10146 
  def __ne__(self, other):
10147 
    return not (self == other)
10148 
 
10149 
class markItemAsContentComplete_result:
10150 
  """
10151 
  Attributes:
10152 
   - success
10153 
   - cex
10154 
  """
10155 
 
10156 
  thrift_spec = (
10157 
    (0, TType.BOOL, 'success', None, None, ), # 0
10158 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10159 
  )
10160 
 
10161 
  def __init__(self, success=None, cex=None,):
10162 
    self.success = success
10163 
    self.cex = cex
10164 
 
10165 
  def read(self, iprot):
10166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10168 
      return
10169 
    iprot.readStructBegin()
10170 
    while True:
10171 
      (fname, ftype, fid) = iprot.readFieldBegin()
10172 
      if ftype == TType.STOP:
10173 
        break
10174 
      if fid == 0:
10175 
        if ftype == TType.BOOL:
10176 
          self.success = iprot.readBool();
10177 
        else:
10178 
          iprot.skip(ftype)
10179 
      elif fid == 1:
10180 
        if ftype == TType.STRUCT:
10181 
          self.cex = CatalogServiceException()
10182 
          self.cex.read(iprot)
10183 
        else:
10184 
          iprot.skip(ftype)
10185 
      else:
10186 
        iprot.skip(ftype)
10187 
      iprot.readFieldEnd()
10188 
    iprot.readStructEnd()
10189 
 
10190 
  def write(self, oprot):
10191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10193 
      return
10194 
    oprot.writeStructBegin('markItemAsContentComplete_result')
10195 
    if self.success is not None:
10196 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10197 
      oprot.writeBool(self.success)
10198 
      oprot.writeFieldEnd()
10199 
    if self.cex is not None:
10200 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10201 
      self.cex.write(oprot)
10202 
      oprot.writeFieldEnd()
10203 
    oprot.writeFieldStop()
10204 
    oprot.writeStructEnd()
10205 
 
10206 
  def validate(self):
10207 
    return
10208 
 
10209 
 
10210 
  def __repr__(self):
10211 
    L = ['%s=%r' % (key, value)
10212 
      for key, value in self.__dict__.iteritems()]
10213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10214 
 
10215 
  def __eq__(self, other):
10216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10217 
 
10218 
  def __ne__(self, other):
10219 
    return not (self == other)
10220 
 
10221 
class getAllItemsInRange_args:
10222 
  """
10223 
  Attributes:
10224 
   - offset
10225 
   - limit
10226 
  """
10227 
 
10228 
  thrift_spec = (
10229 
    None, # 0
10230 
    (1, TType.I64, 'offset', None, None, ), # 1
10231 
    (2, TType.I64, 'limit', None, None, ), # 2
10232 
  )
10233 
 
10234 
  def __init__(self, offset=None, limit=None,):
10235 
    self.offset = offset
10236 
    self.limit = limit
10237 
 
10238 
  def read(self, iprot):
10239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10241 
      return
10242 
    iprot.readStructBegin()
10243 
    while True:
10244 
      (fname, ftype, fid) = iprot.readFieldBegin()
10245 
      if ftype == TType.STOP:
10246 
        break
10247 
      if fid == 1:
10248 
        if ftype == TType.I64:
10249 
          self.offset = iprot.readI64();
10250 
        else:
10251 
          iprot.skip(ftype)
10252 
      elif fid == 2:
10253 
        if ftype == TType.I64:
10254 
          self.limit = iprot.readI64();
10255 
        else:
10256 
          iprot.skip(ftype)
10257 
      else:
10258 
        iprot.skip(ftype)
10259 
      iprot.readFieldEnd()
10260 
    iprot.readStructEnd()
10261 
 
10262 
  def write(self, oprot):
10263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10265 
      return
10266 
    oprot.writeStructBegin('getAllItemsInRange_args')
10267 
    if self.offset is not None:
10268 
      oprot.writeFieldBegin('offset', TType.I64, 1)
10269 
      oprot.writeI64(self.offset)
10270 
      oprot.writeFieldEnd()
10271 
    if self.limit is not None:
10272 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10273 
      oprot.writeI64(self.limit)
10274 
      oprot.writeFieldEnd()
10275 
    oprot.writeFieldStop()
10276 
    oprot.writeStructEnd()
10277 
 
10278 
  def validate(self):
10279 
    return
10280 
 
10281 
 
10282 
  def __repr__(self):
10283 
    L = ['%s=%r' % (key, value)
10284 
      for key, value in self.__dict__.iteritems()]
10285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10286 
 
10287 
  def __eq__(self, other):
10288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10289 
 
10290 
  def __ne__(self, other):
10291 
    return not (self == other)
10292 
 
10293 
class getAllItemsInRange_result:
10294 
  """
10295 
  Attributes:
10296 
   - success
10297 
   - cex
10298 
  """
10299 
 
10300 
  thrift_spec = (
10301 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10302 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10303 
  )
10304 
 
10305 
  def __init__(self, success=None, cex=None,):
10306 
    self.success = success
10307 
    self.cex = cex
10308 
 
10309 
  def read(self, iprot):
10310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10312 
      return
10313 
    iprot.readStructBegin()
10314 
    while True:
10315 
      (fname, ftype, fid) = iprot.readFieldBegin()
10316 
      if ftype == TType.STOP:
10317 
        break
10318 
      if fid == 0:
10319 
        if ftype == TType.LIST:
10320 
          self.success = []
8590 kshitij.so 10321 
          (_etype77, _size74) = iprot.readListBegin()
10322 
          for _i78 in xrange(_size74):
10323 
            _elem79 = Item()
10324 
            _elem79.read(iprot)
10325 
            self.success.append(_elem79)
5944 mandeep.dh 10326 
          iprot.readListEnd()
10327 
        else:
10328 
          iprot.skip(ftype)
10329 
      elif fid == 1:
10330 
        if ftype == TType.STRUCT:
10331 
          self.cex = CatalogServiceException()
10332 
          self.cex.read(iprot)
10333 
        else:
10334 
          iprot.skip(ftype)
10335 
      else:
10336 
        iprot.skip(ftype)
10337 
      iprot.readFieldEnd()
10338 
    iprot.readStructEnd()
10339 
 
10340 
  def write(self, oprot):
10341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10343 
      return
10344 
    oprot.writeStructBegin('getAllItemsInRange_result')
10345 
    if self.success is not None:
10346 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10347 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10348 
      for iter80 in self.success:
10349 
        iter80.write(oprot)
5944 mandeep.dh 10350 
      oprot.writeListEnd()
10351 
      oprot.writeFieldEnd()
10352 
    if self.cex is not None:
10353 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10354 
      self.cex.write(oprot)
10355 
      oprot.writeFieldEnd()
10356 
    oprot.writeFieldStop()
10357 
    oprot.writeStructEnd()
10358 
 
10359 
  def validate(self):
10360 
    return
10361 
 
10362 
 
10363 
  def __repr__(self):
10364 
    L = ['%s=%r' % (key, value)
10365 
      for key, value in self.__dict__.iteritems()]
10366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10367 
 
10368 
  def __eq__(self, other):
10369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10370 
 
10371 
  def __ne__(self, other):
10372 
    return not (self == other)
10373 
 
10374 
class getAllItemsByStatusInRange_args:
10375 
  """
10376 
  Attributes:
10377 
   - itemStatus
10378 
   - offset
10379 
   - limit
10380 
  """
10381 
 
10382 
  thrift_spec = (
10383 
    None, # 0
10384 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
10385 
    (2, TType.I64, 'offset', None, None, ), # 2
10386 
    (3, TType.I64, 'limit', None, None, ), # 3
10387 
  )
10388 
 
10389 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
10390 
    self.itemStatus = itemStatus
10391 
    self.offset = offset
10392 
    self.limit = limit
10393 
 
10394 
  def read(self, iprot):
10395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10397 
      return
10398 
    iprot.readStructBegin()
10399 
    while True:
10400 
      (fname, ftype, fid) = iprot.readFieldBegin()
10401 
      if ftype == TType.STOP:
10402 
        break
10403 
      if fid == 1:
10404 
        if ftype == TType.I32:
10405 
          self.itemStatus = iprot.readI32();
10406 
        else:
10407 
          iprot.skip(ftype)
10408 
      elif fid == 2:
10409 
        if ftype == TType.I64:
10410 
          self.offset = iprot.readI64();
10411 
        else:
10412 
          iprot.skip(ftype)
10413 
      elif fid == 3:
10414 
        if ftype == TType.I64:
10415 
          self.limit = iprot.readI64();
10416 
        else:
10417 
          iprot.skip(ftype)
10418 
      else:
10419 
        iprot.skip(ftype)
10420 
      iprot.readFieldEnd()
10421 
    iprot.readStructEnd()
10422 
 
10423 
  def write(self, oprot):
10424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10426 
      return
10427 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
10428 
    if self.itemStatus is not None:
10429 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
10430 
      oprot.writeI32(self.itemStatus)
10431 
      oprot.writeFieldEnd()
10432 
    if self.offset is not None:
10433 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10434 
      oprot.writeI64(self.offset)
10435 
      oprot.writeFieldEnd()
10436 
    if self.limit is not None:
10437 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10438 
      oprot.writeI64(self.limit)
10439 
      oprot.writeFieldEnd()
10440 
    oprot.writeFieldStop()
10441 
    oprot.writeStructEnd()
10442 
 
10443 
  def validate(self):
10444 
    return
10445 
 
10446 
 
10447 
  def __repr__(self):
10448 
    L = ['%s=%r' % (key, value)
10449 
      for key, value in self.__dict__.iteritems()]
10450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10451 
 
10452 
  def __eq__(self, other):
10453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10454 
 
10455 
  def __ne__(self, other):
10456 
    return not (self == other)
10457 
 
10458 
class getAllItemsByStatusInRange_result:
10459 
  """
10460 
  Attributes:
10461 
   - success
10462 
   - cex
10463 
  """
10464 
 
10465 
  thrift_spec = (
10466 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10467 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10468 
  )
10469 
 
10470 
  def __init__(self, success=None, cex=None,):
10471 
    self.success = success
10472 
    self.cex = cex
10473 
 
10474 
  def read(self, iprot):
10475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10477 
      return
10478 
    iprot.readStructBegin()
10479 
    while True:
10480 
      (fname, ftype, fid) = iprot.readFieldBegin()
10481 
      if ftype == TType.STOP:
10482 
        break
10483 
      if fid == 0:
10484 
        if ftype == TType.LIST:
10485 
          self.success = []
8590 kshitij.so 10486 
          (_etype84, _size81) = iprot.readListBegin()
10487 
          for _i85 in xrange(_size81):
10488 
            _elem86 = Item()
10489 
            _elem86.read(iprot)
10490 
            self.success.append(_elem86)
5944 mandeep.dh 10491 
          iprot.readListEnd()
10492 
        else:
10493 
          iprot.skip(ftype)
10494 
      elif fid == 1:
10495 
        if ftype == TType.STRUCT:
10496 
          self.cex = CatalogServiceException()
10497 
          self.cex.read(iprot)
10498 
        else:
10499 
          iprot.skip(ftype)
10500 
      else:
10501 
        iprot.skip(ftype)
10502 
      iprot.readFieldEnd()
10503 
    iprot.readStructEnd()
10504 
 
10505 
  def write(self, oprot):
10506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10508 
      return
10509 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
10510 
    if self.success is not None:
10511 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10512 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10513 
      for iter87 in self.success:
10514 
        iter87.write(oprot)
5944 mandeep.dh 10515 
      oprot.writeListEnd()
10516 
      oprot.writeFieldEnd()
10517 
    if self.cex is not None:
10518 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10519 
      self.cex.write(oprot)
10520 
      oprot.writeFieldEnd()
10521 
    oprot.writeFieldStop()
10522 
    oprot.writeStructEnd()
10523 
 
10524 
  def validate(self):
10525 
    return
10526 
 
10527 
 
10528 
  def __repr__(self):
10529 
    L = ['%s=%r' % (key, value)
10530 
      for key, value in self.__dict__.iteritems()]
10531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10532 
 
10533 
  def __eq__(self, other):
10534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10535 
 
10536 
  def __ne__(self, other):
10537 
    return not (self == other)
10538 
 
10539 
class getItemCountByStatus_args:
10540 
  """
10541 
  Attributes:
10542 
   - useStatus
10543 
   - itemStatus
10544 
  """
10545 
 
10546 
  thrift_spec = (
10547 
    None, # 0
10548 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
10549 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
10550 
  )
10551 
 
10552 
  def __init__(self, useStatus=None, itemStatus=None,):
10553 
    self.useStatus = useStatus
10554 
    self.itemStatus = itemStatus
10555 
 
10556 
  def read(self, iprot):
10557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10559 
      return
10560 
    iprot.readStructBegin()
10561 
    while True:
10562 
      (fname, ftype, fid) = iprot.readFieldBegin()
10563 
      if ftype == TType.STOP:
10564 
        break
10565 
      if fid == 1:
10566 
        if ftype == TType.BOOL:
10567 
          self.useStatus = iprot.readBool();
10568 
        else:
10569 
          iprot.skip(ftype)
10570 
      elif fid == 2:
10571 
        if ftype == TType.I32:
10572 
          self.itemStatus = iprot.readI32();
10573 
        else:
10574 
          iprot.skip(ftype)
10575 
      else:
10576 
        iprot.skip(ftype)
10577 
      iprot.readFieldEnd()
10578 
    iprot.readStructEnd()
10579 
 
10580 
  def write(self, oprot):
10581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10583 
      return
10584 
    oprot.writeStructBegin('getItemCountByStatus_args')
10585 
    if self.useStatus is not None:
10586 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
10587 
      oprot.writeBool(self.useStatus)
10588 
      oprot.writeFieldEnd()
10589 
    if self.itemStatus is not None:
10590 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
10591 
      oprot.writeI32(self.itemStatus)
10592 
      oprot.writeFieldEnd()
10593 
    oprot.writeFieldStop()
10594 
    oprot.writeStructEnd()
10595 
 
10596 
  def validate(self):
10597 
    return
10598 
 
10599 
 
10600 
  def __repr__(self):
10601 
    L = ['%s=%r' % (key, value)
10602 
      for key, value in self.__dict__.iteritems()]
10603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10604 
 
10605 
  def __eq__(self, other):
10606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10607 
 
10608 
  def __ne__(self, other):
10609 
    return not (self == other)
10610 
 
10611 
class getItemCountByStatus_result:
10612 
  """
10613 
  Attributes:
10614 
   - success
10615 
  """
10616 
 
10617 
  thrift_spec = (
10618 
    (0, TType.I32, 'success', None, None, ), # 0
10619 
  )
10620 
 
10621 
  def __init__(self, success=None,):
10622 
    self.success = success
10623 
 
10624 
  def read(self, iprot):
10625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10627 
      return
10628 
    iprot.readStructBegin()
10629 
    while True:
10630 
      (fname, ftype, fid) = iprot.readFieldBegin()
10631 
      if ftype == TType.STOP:
10632 
        break
10633 
      if fid == 0:
10634 
        if ftype == TType.I32:
10635 
          self.success = iprot.readI32();
10636 
        else:
10637 
          iprot.skip(ftype)
10638 
      else:
10639 
        iprot.skip(ftype)
10640 
      iprot.readFieldEnd()
10641 
    iprot.readStructEnd()
10642 
 
10643 
  def write(self, oprot):
10644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10646 
      return
10647 
    oprot.writeStructBegin('getItemCountByStatus_result')
10648 
    if self.success is not None:
10649 
      oprot.writeFieldBegin('success', TType.I32, 0)
10650 
      oprot.writeI32(self.success)
10651 
      oprot.writeFieldEnd()
10652 
    oprot.writeFieldStop()
10653 
    oprot.writeStructEnd()
10654 
 
10655 
  def validate(self):
10656 
    return
10657 
 
10658 
 
10659 
  def __repr__(self):
10660 
    L = ['%s=%r' % (key, value)
10661 
      for key, value in self.__dict__.iteritems()]
10662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10663 
 
10664 
  def __eq__(self, other):
10665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10666 
 
10667 
  def __ne__(self, other):
10668 
    return not (self == other)
10669 
 
10670 
class getBestSellers_args:
10671 
 
10672 
  thrift_spec = (
10673 
  )
10674 
 
10675 
  def read(self, iprot):
10676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10678 
      return
10679 
    iprot.readStructBegin()
10680 
    while True:
10681 
      (fname, ftype, fid) = iprot.readFieldBegin()
10682 
      if ftype == TType.STOP:
10683 
        break
10684 
      else:
10685 
        iprot.skip(ftype)
10686 
      iprot.readFieldEnd()
10687 
    iprot.readStructEnd()
10688 
 
10689 
  def write(self, oprot):
10690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10692 
      return
10693 
    oprot.writeStructBegin('getBestSellers_args')
10694 
    oprot.writeFieldStop()
10695 
    oprot.writeStructEnd()
10696 
 
10697 
  def validate(self):
10698 
    return
10699 
 
10700 
 
10701 
  def __repr__(self):
10702 
    L = ['%s=%r' % (key, value)
10703 
      for key, value in self.__dict__.iteritems()]
10704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10705 
 
10706 
  def __eq__(self, other):
10707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10708 
 
10709 
  def __ne__(self, other):
10710 
    return not (self == other)
10711 
 
10712 
class getBestSellers_result:
10713 
  """
10714 
  Attributes:
10715 
   - success
10716 
   - isex
10717 
  """
10718 
 
10719 
  thrift_spec = (
10720 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10721 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10722 
  )
10723 
 
10724 
  def __init__(self, success=None, isex=None,):
10725 
    self.success = success
10726 
    self.isex = isex
10727 
 
10728 
  def read(self, iprot):
10729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10731 
      return
10732 
    iprot.readStructBegin()
10733 
    while True:
10734 
      (fname, ftype, fid) = iprot.readFieldBegin()
10735 
      if ftype == TType.STOP:
10736 
        break
10737 
      if fid == 0:
10738 
        if ftype == TType.LIST:
10739 
          self.success = []
8590 kshitij.so 10740 
          (_etype91, _size88) = iprot.readListBegin()
10741 
          for _i92 in xrange(_size88):
10742 
            _elem93 = Item()
10743 
            _elem93.read(iprot)
10744 
            self.success.append(_elem93)
5944 mandeep.dh 10745 
          iprot.readListEnd()
10746 
        else:
10747 
          iprot.skip(ftype)
10748 
      elif fid == 1:
10749 
        if ftype == TType.STRUCT:
10750 
          self.isex = CatalogServiceException()
10751 
          self.isex.read(iprot)
10752 
        else:
10753 
          iprot.skip(ftype)
10754 
      else:
10755 
        iprot.skip(ftype)
10756 
      iprot.readFieldEnd()
10757 
    iprot.readStructEnd()
10758 
 
10759 
  def write(self, oprot):
10760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10762 
      return
10763 
    oprot.writeStructBegin('getBestSellers_result')
10764 
    if self.success is not None:
10765 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10766 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10767 
      for iter94 in self.success:
10768 
        iter94.write(oprot)
5944 mandeep.dh 10769 
      oprot.writeListEnd()
10770 
      oprot.writeFieldEnd()
10771 
    if self.isex is not None:
10772 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10773 
      self.isex.write(oprot)
10774 
      oprot.writeFieldEnd()
10775 
    oprot.writeFieldStop()
10776 
    oprot.writeStructEnd()
10777 
 
10778 
  def validate(self):
10779 
    return
10780 
 
10781 
 
10782 
  def __repr__(self):
10783 
    L = ['%s=%r' % (key, value)
10784 
      for key, value in self.__dict__.iteritems()]
10785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10786 
 
10787 
  def __eq__(self, other):
10788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10789 
 
10790 
  def __ne__(self, other):
10791 
    return not (self == other)
10792 
 
10793 
class getBestSellersCatalogIds_args:
10794 
  """
10795 
  Attributes:
10796 
   - beginIndex
10797 
   - totalItems
10798 
   - brand
10799 
   - category
10800 
  """
10801 
 
10802 
  thrift_spec = (
10803 
    None, # 0
10804 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10805 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10806 
    (3, TType.STRING, 'brand', None, None, ), # 3
10807 
    (4, TType.I64, 'category', None, None, ), # 4
10808 
  )
10809 
 
10810 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10811 
    self.beginIndex = beginIndex
10812 
    self.totalItems = totalItems
10813 
    self.brand = brand
10814 
    self.category = category
10815 
 
10816 
  def read(self, iprot):
10817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10819 
      return
10820 
    iprot.readStructBegin()
10821 
    while True:
10822 
      (fname, ftype, fid) = iprot.readFieldBegin()
10823 
      if ftype == TType.STOP:
10824 
        break
10825 
      if fid == 1:
10826 
        if ftype == TType.I64:
10827 
          self.beginIndex = iprot.readI64();
10828 
        else:
10829 
          iprot.skip(ftype)
10830 
      elif fid == 2:
10831 
        if ftype == TType.I64:
10832 
          self.totalItems = iprot.readI64();
10833 
        else:
10834 
          iprot.skip(ftype)
10835 
      elif fid == 3:
10836 
        if ftype == TType.STRING:
10837 
          self.brand = iprot.readString();
10838 
        else:
10839 
          iprot.skip(ftype)
10840 
      elif fid == 4:
10841 
        if ftype == TType.I64:
10842 
          self.category = iprot.readI64();
10843 
        else:
10844 
          iprot.skip(ftype)
10845 
      else:
10846 
        iprot.skip(ftype)
10847 
      iprot.readFieldEnd()
10848 
    iprot.readStructEnd()
10849 
 
10850 
  def write(self, oprot):
10851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10853 
      return
10854 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
10855 
    if self.beginIndex is not None:
10856 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10857 
      oprot.writeI64(self.beginIndex)
10858 
      oprot.writeFieldEnd()
10859 
    if self.totalItems is not None:
10860 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10861 
      oprot.writeI64(self.totalItems)
10862 
      oprot.writeFieldEnd()
10863 
    if self.brand is not None:
10864 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10865 
      oprot.writeString(self.brand)
10866 
      oprot.writeFieldEnd()
10867 
    if self.category is not None:
10868 
      oprot.writeFieldBegin('category', TType.I64, 4)
10869 
      oprot.writeI64(self.category)
10870 
      oprot.writeFieldEnd()
10871 
    oprot.writeFieldStop()
10872 
    oprot.writeStructEnd()
10873 
 
10874 
  def validate(self):
10875 
    return
10876 
 
10877 
 
10878 
  def __repr__(self):
10879 
    L = ['%s=%r' % (key, value)
10880 
      for key, value in self.__dict__.iteritems()]
10881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10882 
 
10883 
  def __eq__(self, other):
10884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10885 
 
10886 
  def __ne__(self, other):
10887 
    return not (self == other)
10888 
 
10889 
class getBestSellersCatalogIds_result:
10890 
  """
10891 
  Attributes:
10892 
   - success
10893 
   - cex
10894 
  """
10895 
 
10896 
  thrift_spec = (
10897 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10898 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10899 
  )
10900 
 
10901 
  def __init__(self, success=None, cex=None,):
10902 
    self.success = success
10903 
    self.cex = cex
10904 
 
10905 
  def read(self, iprot):
10906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10908 
      return
10909 
    iprot.readStructBegin()
10910 
    while True:
10911 
      (fname, ftype, fid) = iprot.readFieldBegin()
10912 
      if ftype == TType.STOP:
10913 
        break
10914 
      if fid == 0:
10915 
        if ftype == TType.LIST:
10916 
          self.success = []
8590 kshitij.so 10917 
          (_etype98, _size95) = iprot.readListBegin()
10918 
          for _i99 in xrange(_size95):
10919 
            _elem100 = iprot.readI64();
10920 
            self.success.append(_elem100)
5944 mandeep.dh 10921 
          iprot.readListEnd()
10922 
        else:
10923 
          iprot.skip(ftype)
10924 
      elif fid == 1:
10925 
        if ftype == TType.STRUCT:
10926 
          self.cex = CatalogServiceException()
10927 
          self.cex.read(iprot)
10928 
        else:
10929 
          iprot.skip(ftype)
10930 
      else:
10931 
        iprot.skip(ftype)
10932 
      iprot.readFieldEnd()
10933 
    iprot.readStructEnd()
10934 
 
10935 
  def write(self, oprot):
10936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10938 
      return
10939 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
10940 
    if self.success is not None:
10941 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10942 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10943 
      for iter101 in self.success:
10944 
        oprot.writeI64(iter101)
5944 mandeep.dh 10945 
      oprot.writeListEnd()
10946 
      oprot.writeFieldEnd()
10947 
    if self.cex is not None:
10948 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10949 
      self.cex.write(oprot)
10950 
      oprot.writeFieldEnd()
10951 
    oprot.writeFieldStop()
10952 
    oprot.writeStructEnd()
10953 
 
10954 
  def validate(self):
10955 
    return
10956 
 
10957 
 
10958 
  def __repr__(self):
10959 
    L = ['%s=%r' % (key, value)
10960 
      for key, value in self.__dict__.iteritems()]
10961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10962 
 
10963 
  def __eq__(self, other):
10964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10965 
 
10966 
  def __ne__(self, other):
10967 
    return not (self == other)
10968 
 
10969 
class getBestSellersCount_args:
10970 
 
10971 
  thrift_spec = (
10972 
  )
10973 
 
10974 
  def read(self, iprot):
10975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10977 
      return
10978 
    iprot.readStructBegin()
10979 
    while True:
10980 
      (fname, ftype, fid) = iprot.readFieldBegin()
10981 
      if ftype == TType.STOP:
10982 
        break
10983 
      else:
10984 
        iprot.skip(ftype)
10985 
      iprot.readFieldEnd()
10986 
    iprot.readStructEnd()
10987 
 
10988 
  def write(self, oprot):
10989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10991 
      return
10992 
    oprot.writeStructBegin('getBestSellersCount_args')
10993 
    oprot.writeFieldStop()
10994 
    oprot.writeStructEnd()
10995 
 
10996 
  def validate(self):
10997 
    return
10998 
 
10999 
 
11000 
  def __repr__(self):
11001 
    L = ['%s=%r' % (key, value)
11002 
      for key, value in self.__dict__.iteritems()]
11003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11004 
 
11005 
  def __eq__(self, other):
11006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11007 
 
11008 
  def __ne__(self, other):
11009 
    return not (self == other)
11010 
 
11011 
class getBestSellersCount_result:
11012 
  """
11013 
  Attributes:
11014 
   - success
11015 
   - cex
11016 
  """
11017 
 
11018 
  thrift_spec = (
11019 
    (0, TType.I64, 'success', None, None, ), # 0
11020 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11021 
  )
11022 
 
11023 
  def __init__(self, success=None, cex=None,):
11024 
    self.success = success
11025 
    self.cex = cex
11026 
 
11027 
  def read(self, iprot):
11028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11030 
      return
11031 
    iprot.readStructBegin()
11032 
    while True:
11033 
      (fname, ftype, fid) = iprot.readFieldBegin()
11034 
      if ftype == TType.STOP:
11035 
        break
11036 
      if fid == 0:
11037 
        if ftype == TType.I64:
11038 
          self.success = iprot.readI64();
11039 
        else:
11040 
          iprot.skip(ftype)
11041 
      elif fid == 1:
11042 
        if ftype == TType.STRUCT:
11043 
          self.cex = CatalogServiceException()
11044 
          self.cex.read(iprot)
11045 
        else:
11046 
          iprot.skip(ftype)
11047 
      else:
11048 
        iprot.skip(ftype)
11049 
      iprot.readFieldEnd()
11050 
    iprot.readStructEnd()
11051 
 
11052 
  def write(self, oprot):
11053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11055 
      return
11056 
    oprot.writeStructBegin('getBestSellersCount_result')
11057 
    if self.success is not None:
11058 
      oprot.writeFieldBegin('success', TType.I64, 0)
11059 
      oprot.writeI64(self.success)
11060 
      oprot.writeFieldEnd()
11061 
    if self.cex is not None:
11062 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11063 
      self.cex.write(oprot)
11064 
      oprot.writeFieldEnd()
11065 
    oprot.writeFieldStop()
11066 
    oprot.writeStructEnd()
11067 
 
11068 
  def validate(self):
11069 
    return
11070 
 
11071 
 
11072 
  def __repr__(self):
11073 
    L = ['%s=%r' % (key, value)
11074 
      for key, value in self.__dict__.iteritems()]
11075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11076 
 
11077 
  def __eq__(self, other):
11078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11079 
 
11080 
  def __ne__(self, other):
11081 
    return not (self == other)
11082 
 
11083 
class getBestDeals_args:
11084 
 
11085 
  thrift_spec = (
11086 
  )
11087 
 
11088 
  def read(self, iprot):
11089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11091 
      return
11092 
    iprot.readStructBegin()
11093 
    while True:
11094 
      (fname, ftype, fid) = iprot.readFieldBegin()
11095 
      if ftype == TType.STOP:
11096 
        break
11097 
      else:
11098 
        iprot.skip(ftype)
11099 
      iprot.readFieldEnd()
11100 
    iprot.readStructEnd()
11101 
 
11102 
  def write(self, oprot):
11103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11105 
      return
11106 
    oprot.writeStructBegin('getBestDeals_args')
11107 
    oprot.writeFieldStop()
11108 
    oprot.writeStructEnd()
11109 
 
11110 
  def validate(self):
11111 
    return
11112 
 
11113 
 
11114 
  def __repr__(self):
11115 
    L = ['%s=%r' % (key, value)
11116 
      for key, value in self.__dict__.iteritems()]
11117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11118 
 
11119 
  def __eq__(self, other):
11120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11121 
 
11122 
  def __ne__(self, other):
11123 
    return not (self == other)
11124 
 
11125 
class getBestDeals_result:
11126 
  """
11127 
  Attributes:
11128 
   - success
11129 
   - isex
11130 
  """
11131 
 
11132 
  thrift_spec = (
11133 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11134 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11135 
  )
11136 
 
11137 
  def __init__(self, success=None, isex=None,):
11138 
    self.success = success
11139 
    self.isex = isex
11140 
 
11141 
  def read(self, iprot):
11142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11144 
      return
11145 
    iprot.readStructBegin()
11146 
    while True:
11147 
      (fname, ftype, fid) = iprot.readFieldBegin()
11148 
      if ftype == TType.STOP:
11149 
        break
11150 
      if fid == 0:
11151 
        if ftype == TType.LIST:
11152 
          self.success = []
8590 kshitij.so 11153 
          (_etype105, _size102) = iprot.readListBegin()
11154 
          for _i106 in xrange(_size102):
11155 
            _elem107 = Item()
11156 
            _elem107.read(iprot)
11157 
            self.success.append(_elem107)
5944 mandeep.dh 11158 
          iprot.readListEnd()
11159 
        else:
11160 
          iprot.skip(ftype)
11161 
      elif fid == 1:
11162 
        if ftype == TType.STRUCT:
11163 
          self.isex = CatalogServiceException()
11164 
          self.isex.read(iprot)
11165 
        else:
11166 
          iprot.skip(ftype)
11167 
      else:
11168 
        iprot.skip(ftype)
11169 
      iprot.readFieldEnd()
11170 
    iprot.readStructEnd()
11171 
 
11172 
  def write(self, oprot):
11173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11175 
      return
11176 
    oprot.writeStructBegin('getBestDeals_result')
11177 
    if self.success is not None:
11178 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11179 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11180 
      for iter108 in self.success:
11181 
        iter108.write(oprot)
5944 mandeep.dh 11182 
      oprot.writeListEnd()
11183 
      oprot.writeFieldEnd()
11184 
    if self.isex is not None:
11185 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11186 
      self.isex.write(oprot)
11187 
      oprot.writeFieldEnd()
11188 
    oprot.writeFieldStop()
11189 
    oprot.writeStructEnd()
11190 
 
11191 
  def validate(self):
11192 
    return
11193 
 
11194 
 
11195 
  def __repr__(self):
11196 
    L = ['%s=%r' % (key, value)
11197 
      for key, value in self.__dict__.iteritems()]
11198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11199 
 
11200 
  def __eq__(self, other):
11201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11202 
 
11203 
  def __ne__(self, other):
11204 
    return not (self == other)
11205 
 
11206 
class getBestDealsCatalogIds_args:
11207 
  """
11208 
  Attributes:
11209 
   - beginIndex
11210 
   - totalItems
11211 
   - brand
11212 
   - category
11213 
  """
11214 
 
11215 
  thrift_spec = (
11216 
    None, # 0
11217 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11218 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11219 
    (3, TType.STRING, 'brand', None, None, ), # 3
11220 
    (4, TType.I64, 'category', None, None, ), # 4
11221 
  )
11222 
 
11223 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
11224 
    self.beginIndex = beginIndex
11225 
    self.totalItems = totalItems
11226 
    self.brand = brand
11227 
    self.category = category
11228 
 
11229 
  def read(self, iprot):
11230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11232 
      return
11233 
    iprot.readStructBegin()
11234 
    while True:
11235 
      (fname, ftype, fid) = iprot.readFieldBegin()
11236 
      if ftype == TType.STOP:
11237 
        break
11238 
      if fid == 1:
11239 
        if ftype == TType.I64:
11240 
          self.beginIndex = iprot.readI64();
11241 
        else:
11242 
          iprot.skip(ftype)
11243 
      elif fid == 2:
11244 
        if ftype == TType.I64:
11245 
          self.totalItems = iprot.readI64();
11246 
        else:
11247 
          iprot.skip(ftype)
11248 
      elif fid == 3:
11249 
        if ftype == TType.STRING:
11250 
          self.brand = iprot.readString();
11251 
        else:
11252 
          iprot.skip(ftype)
11253 
      elif fid == 4:
11254 
        if ftype == TType.I64:
11255 
          self.category = iprot.readI64();
11256 
        else:
11257 
          iprot.skip(ftype)
11258 
      else:
11259 
        iprot.skip(ftype)
11260 
      iprot.readFieldEnd()
11261 
    iprot.readStructEnd()
11262 
 
11263 
  def write(self, oprot):
11264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11266 
      return
11267 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
11268 
    if self.beginIndex is not None:
11269 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11270 
      oprot.writeI64(self.beginIndex)
11271 
      oprot.writeFieldEnd()
11272 
    if self.totalItems is not None:
11273 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11274 
      oprot.writeI64(self.totalItems)
11275 
      oprot.writeFieldEnd()
11276 
    if self.brand is not None:
11277 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11278 
      oprot.writeString(self.brand)
11279 
      oprot.writeFieldEnd()
11280 
    if self.category is not None:
11281 
      oprot.writeFieldBegin('category', TType.I64, 4)
11282 
      oprot.writeI64(self.category)
11283 
      oprot.writeFieldEnd()
11284 
    oprot.writeFieldStop()
11285 
    oprot.writeStructEnd()
11286 
 
11287 
  def validate(self):
11288 
    return
11289 
 
11290 
 
11291 
  def __repr__(self):
11292 
    L = ['%s=%r' % (key, value)
11293 
      for key, value in self.__dict__.iteritems()]
11294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11295 
 
11296 
  def __eq__(self, other):
11297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11298 
 
11299 
  def __ne__(self, other):
11300 
    return not (self == other)
11301 
 
11302 
class getBestDealsCatalogIds_result:
11303 
  """
11304 
  Attributes:
11305 
   - success
11306 
   - cex
11307 
  """
11308 
 
11309 
  thrift_spec = (
11310 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11311 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11312 
  )
11313 
 
11314 
  def __init__(self, success=None, cex=None,):
11315 
    self.success = success
11316 
    self.cex = cex
11317 
 
11318 
  def read(self, iprot):
11319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11321 
      return
11322 
    iprot.readStructBegin()
11323 
    while True:
11324 
      (fname, ftype, fid) = iprot.readFieldBegin()
11325 
      if ftype == TType.STOP:
11326 
        break
11327 
      if fid == 0:
11328 
        if ftype == TType.LIST:
11329 
          self.success = []
8590 kshitij.so 11330 
          (_etype112, _size109) = iprot.readListBegin()
11331 
          for _i113 in xrange(_size109):
11332 
            _elem114 = iprot.readI64();
11333 
            self.success.append(_elem114)
5944 mandeep.dh 11334 
          iprot.readListEnd()
11335 
        else:
11336 
          iprot.skip(ftype)
11337 
      elif fid == 1:
11338 
        if ftype == TType.STRUCT:
11339 
          self.cex = CatalogServiceException()
11340 
          self.cex.read(iprot)
11341 
        else:
11342 
          iprot.skip(ftype)
11343 
      else:
11344 
        iprot.skip(ftype)
11345 
      iprot.readFieldEnd()
11346 
    iprot.readStructEnd()
11347 
 
11348 
  def write(self, oprot):
11349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11351 
      return
11352 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
11353 
    if self.success is not None:
11354 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11355 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11356 
      for iter115 in self.success:
11357 
        oprot.writeI64(iter115)
5944 mandeep.dh 11358 
      oprot.writeListEnd()
11359 
      oprot.writeFieldEnd()
11360 
    if self.cex is not None:
11361 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11362 
      self.cex.write(oprot)
11363 
      oprot.writeFieldEnd()
11364 
    oprot.writeFieldStop()
11365 
    oprot.writeStructEnd()
11366 
 
11367 
  def validate(self):
11368 
    return
11369 
 
11370 
 
11371 
  def __repr__(self):
11372 
    L = ['%s=%r' % (key, value)
11373 
      for key, value in self.__dict__.iteritems()]
11374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11375 
 
11376 
  def __eq__(self, other):
11377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11378 
 
11379 
  def __ne__(self, other):
11380 
    return not (self == other)
11381 
 
11382 
class getBestDealsCount_args:
11383 
 
11384 
  thrift_spec = (
11385 
  )
11386 
 
11387 
  def read(self, iprot):
11388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11390 
      return
11391 
    iprot.readStructBegin()
11392 
    while True:
11393 
      (fname, ftype, fid) = iprot.readFieldBegin()
11394 
      if ftype == TType.STOP:
11395 
        break
11396 
      else:
11397 
        iprot.skip(ftype)
11398 
      iprot.readFieldEnd()
11399 
    iprot.readStructEnd()
11400 
 
11401 
  def write(self, oprot):
11402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11404 
      return
11405 
    oprot.writeStructBegin('getBestDealsCount_args')
11406 
    oprot.writeFieldStop()
11407 
    oprot.writeStructEnd()
11408 
 
11409 
  def validate(self):
11410 
    return
11411 
 
11412 
 
11413 
  def __repr__(self):
11414 
    L = ['%s=%r' % (key, value)
11415 
      for key, value in self.__dict__.iteritems()]
11416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11417 
 
11418 
  def __eq__(self, other):
11419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11420 
 
11421 
  def __ne__(self, other):
11422 
    return not (self == other)
11423 
 
11424 
class getBestDealsCount_result:
11425 
  """
11426 
  Attributes:
11427 
   - success
11428 
   - cex
11429 
  """
11430 
 
11431 
  thrift_spec = (
11432 
    (0, TType.I64, 'success', None, None, ), # 0
11433 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11434 
  )
11435 
 
11436 
  def __init__(self, success=None, cex=None,):
11437 
    self.success = success
11438 
    self.cex = cex
11439 
 
11440 
  def read(self, iprot):
11441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11443 
      return
11444 
    iprot.readStructBegin()
11445 
    while True:
11446 
      (fname, ftype, fid) = iprot.readFieldBegin()
11447 
      if ftype == TType.STOP:
11448 
        break
11449 
      if fid == 0:
11450 
        if ftype == TType.I64:
11451 
          self.success = iprot.readI64();
11452 
        else:
11453 
          iprot.skip(ftype)
11454 
      elif fid == 1:
11455 
        if ftype == TType.STRUCT:
11456 
          self.cex = CatalogServiceException()
11457 
          self.cex.read(iprot)
11458 
        else:
11459 
          iprot.skip(ftype)
11460 
      else:
11461 
        iprot.skip(ftype)
11462 
      iprot.readFieldEnd()
11463 
    iprot.readStructEnd()
11464 
 
11465 
  def write(self, oprot):
11466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11468 
      return
11469 
    oprot.writeStructBegin('getBestDealsCount_result')
11470 
    if self.success is not None:
11471 
      oprot.writeFieldBegin('success', TType.I64, 0)
11472 
      oprot.writeI64(self.success)
11473 
      oprot.writeFieldEnd()
11474 
    if self.cex is not None:
11475 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11476 
      self.cex.write(oprot)
11477 
      oprot.writeFieldEnd()
11478 
    oprot.writeFieldStop()
11479 
    oprot.writeStructEnd()
11480 
 
11481 
  def validate(self):
11482 
    return
11483 
 
11484 
 
11485 
  def __repr__(self):
11486 
    L = ['%s=%r' % (key, value)
11487 
      for key, value in self.__dict__.iteritems()]
11488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11489 
 
11490 
  def __eq__(self, other):
11491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11492 
 
11493 
  def __ne__(self, other):
11494 
    return not (self == other)
11495 
 
11496 
class getComingSoon_args:
11497 
 
11498 
  thrift_spec = (
11499 
  )
11500 
 
11501 
  def read(self, iprot):
11502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11504 
      return
11505 
    iprot.readStructBegin()
11506 
    while True:
11507 
      (fname, ftype, fid) = iprot.readFieldBegin()
11508 
      if ftype == TType.STOP:
11509 
        break
11510 
      else:
11511 
        iprot.skip(ftype)
11512 
      iprot.readFieldEnd()
11513 
    iprot.readStructEnd()
11514 
 
11515 
  def write(self, oprot):
11516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11518 
      return
11519 
    oprot.writeStructBegin('getComingSoon_args')
11520 
    oprot.writeFieldStop()
11521 
    oprot.writeStructEnd()
11522 
 
11523 
  def validate(self):
11524 
    return
11525 
 
11526 
 
11527 
  def __repr__(self):
11528 
    L = ['%s=%r' % (key, value)
11529 
      for key, value in self.__dict__.iteritems()]
11530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11531 
 
11532 
  def __eq__(self, other):
11533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11534 
 
11535 
  def __ne__(self, other):
11536 
    return not (self == other)
11537 
 
11538 
class getComingSoon_result:
11539 
  """
11540 
  Attributes:
11541 
   - success
11542 
   - isex
11543 
  """
11544 
 
11545 
  thrift_spec = (
11546 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11547 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11548 
  )
11549 
 
11550 
  def __init__(self, success=None, isex=None,):
11551 
    self.success = success
11552 
    self.isex = isex
11553 
 
11554 
  def read(self, iprot):
11555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11557 
      return
11558 
    iprot.readStructBegin()
11559 
    while True:
11560 
      (fname, ftype, fid) = iprot.readFieldBegin()
11561 
      if ftype == TType.STOP:
11562 
        break
11563 
      if fid == 0:
11564 
        if ftype == TType.LIST:
11565 
          self.success = []
8590 kshitij.so 11566 
          (_etype119, _size116) = iprot.readListBegin()
11567 
          for _i120 in xrange(_size116):
11568 
            _elem121 = Item()
11569 
            _elem121.read(iprot)
11570 
            self.success.append(_elem121)
5944 mandeep.dh 11571 
          iprot.readListEnd()
11572 
        else:
11573 
          iprot.skip(ftype)
11574 
      elif fid == 1:
11575 
        if ftype == TType.STRUCT:
11576 
          self.isex = CatalogServiceException()
11577 
          self.isex.read(iprot)
11578 
        else:
11579 
          iprot.skip(ftype)
11580 
      else:
11581 
        iprot.skip(ftype)
11582 
      iprot.readFieldEnd()
11583 
    iprot.readStructEnd()
11584 
 
11585 
  def write(self, oprot):
11586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11588 
      return
11589 
    oprot.writeStructBegin('getComingSoon_result')
11590 
    if self.success is not None:
11591 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11592 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11593 
      for iter122 in self.success:
11594 
        iter122.write(oprot)
5944 mandeep.dh 11595 
      oprot.writeListEnd()
11596 
      oprot.writeFieldEnd()
11597 
    if self.isex is not None:
11598 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11599 
      self.isex.write(oprot)
11600 
      oprot.writeFieldEnd()
11601 
    oprot.writeFieldStop()
11602 
    oprot.writeStructEnd()
11603 
 
11604 
  def validate(self):
11605 
    return
11606 
 
11607 
 
11608 
  def __repr__(self):
11609 
    L = ['%s=%r' % (key, value)
11610 
      for key, value in self.__dict__.iteritems()]
11611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11612 
 
11613 
  def __eq__(self, other):
11614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11615 
 
11616 
  def __ne__(self, other):
11617 
    return not (self == other)
11618 
 
11619 
class getComingSoonCatalogIds_args:
11620 
  """
11621 
  Attributes:
11622 
   - beginIndex
11623 
   - totalItems
11624 
   - brand
11625 
   - category
11626 
  """
11627 
 
11628 
  thrift_spec = (
11629 
    None, # 0
11630 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11631 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11632 
    (3, TType.STRING, 'brand', None, None, ), # 3
11633 
    (4, TType.I64, 'category', None, None, ), # 4
11634 
  )
11635 
 
11636 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
11637 
    self.beginIndex = beginIndex
11638 
    self.totalItems = totalItems
11639 
    self.brand = brand
11640 
    self.category = category
11641 
 
11642 
  def read(self, iprot):
11643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11645 
      return
11646 
    iprot.readStructBegin()
11647 
    while True:
11648 
      (fname, ftype, fid) = iprot.readFieldBegin()
11649 
      if ftype == TType.STOP:
11650 
        break
11651 
      if fid == 1:
11652 
        if ftype == TType.I64:
11653 
          self.beginIndex = iprot.readI64();
11654 
        else:
11655 
          iprot.skip(ftype)
11656 
      elif fid == 2:
11657 
        if ftype == TType.I64:
11658 
          self.totalItems = iprot.readI64();
11659 
        else:
11660 
          iprot.skip(ftype)
11661 
      elif fid == 3:
11662 
        if ftype == TType.STRING:
11663 
          self.brand = iprot.readString();
11664 
        else:
11665 
          iprot.skip(ftype)
11666 
      elif fid == 4:
11667 
        if ftype == TType.I64:
11668 
          self.category = iprot.readI64();
11669 
        else:
11670 
          iprot.skip(ftype)
11671 
      else:
11672 
        iprot.skip(ftype)
11673 
      iprot.readFieldEnd()
11674 
    iprot.readStructEnd()
11675 
 
11676 
  def write(self, oprot):
11677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11679 
      return
11680 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
11681 
    if self.beginIndex is not None:
11682 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11683 
      oprot.writeI64(self.beginIndex)
11684 
      oprot.writeFieldEnd()
11685 
    if self.totalItems is not None:
11686 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11687 
      oprot.writeI64(self.totalItems)
11688 
      oprot.writeFieldEnd()
11689 
    if self.brand is not None:
11690 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11691 
      oprot.writeString(self.brand)
11692 
      oprot.writeFieldEnd()
11693 
    if self.category is not None:
11694 
      oprot.writeFieldBegin('category', TType.I64, 4)
11695 
      oprot.writeI64(self.category)
11696 
      oprot.writeFieldEnd()
11697 
    oprot.writeFieldStop()
11698 
    oprot.writeStructEnd()
11699 
 
11700 
  def validate(self):
11701 
    return
11702 
 
11703 
 
11704 
  def __repr__(self):
11705 
    L = ['%s=%r' % (key, value)
11706 
      for key, value in self.__dict__.iteritems()]
11707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11708 
 
11709 
  def __eq__(self, other):
11710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11711 
 
11712 
  def __ne__(self, other):
11713 
    return not (self == other)
11714 
 
11715 
class getComingSoonCatalogIds_result:
11716 
  """
11717 
  Attributes:
11718 
   - success
11719 
   - cex
11720 
  """
11721 
 
11722 
  thrift_spec = (
11723 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11724 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11725 
  )
11726 
 
11727 
  def __init__(self, success=None, cex=None,):
11728 
    self.success = success
11729 
    self.cex = cex
11730 
 
11731 
  def read(self, iprot):
11732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11734 
      return
11735 
    iprot.readStructBegin()
11736 
    while True:
11737 
      (fname, ftype, fid) = iprot.readFieldBegin()
11738 
      if ftype == TType.STOP:
11739 
        break
11740 
      if fid == 0:
11741 
        if ftype == TType.LIST:
11742 
          self.success = []
8590 kshitij.so 11743 
          (_etype126, _size123) = iprot.readListBegin()
11744 
          for _i127 in xrange(_size123):
11745 
            _elem128 = iprot.readI64();
11746 
            self.success.append(_elem128)
5944 mandeep.dh 11747 
          iprot.readListEnd()
11748 
        else:
11749 
          iprot.skip(ftype)
11750 
      elif fid == 1:
11751 
        if ftype == TType.STRUCT:
11752 
          self.cex = CatalogServiceException()
11753 
          self.cex.read(iprot)
11754 
        else:
11755 
          iprot.skip(ftype)
11756 
      else:
11757 
        iprot.skip(ftype)
11758 
      iprot.readFieldEnd()
11759 
    iprot.readStructEnd()
11760 
 
11761 
  def write(self, oprot):
11762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11764 
      return
11765 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
11766 
    if self.success is not None:
11767 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11768 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11769 
      for iter129 in self.success:
11770 
        oprot.writeI64(iter129)
5944 mandeep.dh 11771 
      oprot.writeListEnd()
11772 
      oprot.writeFieldEnd()
11773 
    if self.cex is not None:
11774 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11775 
      self.cex.write(oprot)
11776 
      oprot.writeFieldEnd()
11777 
    oprot.writeFieldStop()
11778 
    oprot.writeStructEnd()
11779 
 
11780 
  def validate(self):
11781 
    return
11782 
 
11783 
 
11784 
  def __repr__(self):
11785 
    L = ['%s=%r' % (key, value)
11786 
      for key, value in self.__dict__.iteritems()]
11787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11788 
 
11789 
  def __eq__(self, other):
11790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11791 
 
11792 
  def __ne__(self, other):
11793 
    return not (self == other)
11794 
 
11795 
class getComingSoonCount_args:
11796 
 
11797 
  thrift_spec = (
11798 
  )
11799 
 
11800 
  def read(self, iprot):
11801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11803 
      return
11804 
    iprot.readStructBegin()
11805 
    while True:
11806 
      (fname, ftype, fid) = iprot.readFieldBegin()
11807 
      if ftype == TType.STOP:
11808 
        break
11809 
      else:
11810 
        iprot.skip(ftype)
11811 
      iprot.readFieldEnd()
11812 
    iprot.readStructEnd()
11813 
 
11814 
  def write(self, oprot):
11815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11817 
      return
11818 
    oprot.writeStructBegin('getComingSoonCount_args')
11819 
    oprot.writeFieldStop()
11820 
    oprot.writeStructEnd()
11821 
 
11822 
  def validate(self):
11823 
    return
11824 
 
11825 
 
11826 
  def __repr__(self):
11827 
    L = ['%s=%r' % (key, value)
11828 
      for key, value in self.__dict__.iteritems()]
11829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11830 
 
11831 
  def __eq__(self, other):
11832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11833 
 
11834 
  def __ne__(self, other):
11835 
    return not (self == other)
11836 
 
11837 
class getComingSoonCount_result:
11838 
  """
11839 
  Attributes:
11840 
   - success
11841 
   - cex
11842 
  """
11843 
 
11844 
  thrift_spec = (
11845 
    (0, TType.I64, 'success', None, None, ), # 0
11846 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11847 
  )
11848 
 
11849 
  def __init__(self, success=None, cex=None,):
11850 
    self.success = success
11851 
    self.cex = cex
11852 
 
11853 
  def read(self, iprot):
11854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11856 
      return
11857 
    iprot.readStructBegin()
11858 
    while True:
11859 
      (fname, ftype, fid) = iprot.readFieldBegin()
11860 
      if ftype == TType.STOP:
11861 
        break
11862 
      if fid == 0:
11863 
        if ftype == TType.I64:
11864 
          self.success = iprot.readI64();
11865 
        else:
11866 
          iprot.skip(ftype)
11867 
      elif fid == 1:
11868 
        if ftype == TType.STRUCT:
11869 
          self.cex = CatalogServiceException()
11870 
          self.cex.read(iprot)
11871 
        else:
11872 
          iprot.skip(ftype)
11873 
      else:
11874 
        iprot.skip(ftype)
11875 
      iprot.readFieldEnd()
11876 
    iprot.readStructEnd()
11877 
 
11878 
  def write(self, oprot):
11879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11881 
      return
11882 
    oprot.writeStructBegin('getComingSoonCount_result')
11883 
    if self.success is not None:
11884 
      oprot.writeFieldBegin('success', TType.I64, 0)
11885 
      oprot.writeI64(self.success)
11886 
      oprot.writeFieldEnd()
11887 
    if self.cex is not None:
11888 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11889 
      self.cex.write(oprot)
11890 
      oprot.writeFieldEnd()
11891 
    oprot.writeFieldStop()
11892 
    oprot.writeStructEnd()
11893 
 
11894 
  def validate(self):
11895 
    return
11896 
 
11897 
 
11898 
  def __repr__(self):
11899 
    L = ['%s=%r' % (key, value)
11900 
      for key, value in self.__dict__.iteritems()]
11901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11902 
 
11903 
  def __eq__(self, other):
11904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11905 
 
11906 
  def __ne__(self, other):
11907 
    return not (self == other)
11908 
 
11909 
class getLatestArrivals_args:
11910 
 
11911 
  thrift_spec = (
11912 
  )
11913 
 
11914 
  def read(self, iprot):
11915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11917 
      return
11918 
    iprot.readStructBegin()
11919 
    while True:
11920 
      (fname, ftype, fid) = iprot.readFieldBegin()
11921 
      if ftype == TType.STOP:
11922 
        break
11923 
      else:
11924 
        iprot.skip(ftype)
11925 
      iprot.readFieldEnd()
11926 
    iprot.readStructEnd()
11927 
 
11928 
  def write(self, oprot):
11929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11931 
      return
11932 
    oprot.writeStructBegin('getLatestArrivals_args')
11933 
    oprot.writeFieldStop()
11934 
    oprot.writeStructEnd()
11935 
 
11936 
  def validate(self):
11937 
    return
11938 
 
11939 
 
11940 
  def __repr__(self):
11941 
    L = ['%s=%r' % (key, value)
11942 
      for key, value in self.__dict__.iteritems()]
11943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11944 
 
11945 
  def __eq__(self, other):
11946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11947 
 
11948 
  def __ne__(self, other):
11949 
    return not (self == other)
11950 
 
11951 
class getLatestArrivals_result:
11952 
  """
11953 
  Attributes:
11954 
   - success
11955 
   - isex
11956 
  """
11957 
 
11958 
  thrift_spec = (
11959 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11960 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11961 
  )
11962 
 
11963 
  def __init__(self, success=None, isex=None,):
11964 
    self.success = success
11965 
    self.isex = isex
11966 
 
11967 
  def read(self, iprot):
11968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11970 
      return
11971 
    iprot.readStructBegin()
11972 
    while True:
11973 
      (fname, ftype, fid) = iprot.readFieldBegin()
11974 
      if ftype == TType.STOP:
11975 
        break
11976 
      if fid == 0:
11977 
        if ftype == TType.LIST:
11978 
          self.success = []
8590 kshitij.so 11979 
          (_etype133, _size130) = iprot.readListBegin()
11980 
          for _i134 in xrange(_size130):
11981 
            _elem135 = Item()
11982 
            _elem135.read(iprot)
11983 
            self.success.append(_elem135)
5944 mandeep.dh 11984 
          iprot.readListEnd()
11985 
        else:
11986 
          iprot.skip(ftype)
11987 
      elif fid == 1:
11988 
        if ftype == TType.STRUCT:
11989 
          self.isex = CatalogServiceException()
11990 
          self.isex.read(iprot)
11991 
        else:
11992 
          iprot.skip(ftype)
11993 
      else:
11994 
        iprot.skip(ftype)
11995 
      iprot.readFieldEnd()
11996 
    iprot.readStructEnd()
11997 
 
11998 
  def write(self, oprot):
11999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12001 
      return
12002 
    oprot.writeStructBegin('getLatestArrivals_result')
12003 
    if self.success is not None:
12004 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12005 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12006 
      for iter136 in self.success:
12007 
        iter136.write(oprot)
5944 mandeep.dh 12008 
      oprot.writeListEnd()
12009 
      oprot.writeFieldEnd()
12010 
    if self.isex is not None:
12011 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
12012 
      self.isex.write(oprot)
12013 
      oprot.writeFieldEnd()
12014 
    oprot.writeFieldStop()
12015 
    oprot.writeStructEnd()
12016 
 
12017 
  def validate(self):
12018 
    return
12019 
 
12020 
 
12021 
  def __repr__(self):
12022 
    L = ['%s=%r' % (key, value)
12023 
      for key, value in self.__dict__.iteritems()]
12024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12025 
 
12026 
  def __eq__(self, other):
12027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12028 
 
12029 
  def __ne__(self, other):
12030 
    return not (self == other)
12031 
 
12032 
class getLatestArrivalsCatalogIds_args:
12033 
  """
12034 
  Attributes:
12035 
   - beginIndex
12036 
   - totalItems
12037 
   - brand
12038 
   - categories
12039 
  """
12040 
 
12041 
  thrift_spec = (
12042 
    None, # 0
12043 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12044 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12045 
    (3, TType.STRING, 'brand', None, None, ), # 3
12046 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
12047 
  )
12048 
 
12049 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
12050 
    self.beginIndex = beginIndex
12051 
    self.totalItems = totalItems
12052 
    self.brand = brand
12053 
    self.categories = categories
12054 
 
12055 
  def read(self, iprot):
12056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12058 
      return
12059 
    iprot.readStructBegin()
12060 
    while True:
12061 
      (fname, ftype, fid) = iprot.readFieldBegin()
12062 
      if ftype == TType.STOP:
12063 
        break
12064 
      if fid == 1:
12065 
        if ftype == TType.I64:
12066 
          self.beginIndex = iprot.readI64();
12067 
        else:
12068 
          iprot.skip(ftype)
12069 
      elif fid == 2:
12070 
        if ftype == TType.I64:
12071 
          self.totalItems = iprot.readI64();
12072 
        else:
12073 
          iprot.skip(ftype)
12074 
      elif fid == 3:
12075 
        if ftype == TType.STRING:
12076 
          self.brand = iprot.readString();
12077 
        else:
12078 
          iprot.skip(ftype)
12079 
      elif fid == 4:
12080 
        if ftype == TType.LIST:
12081 
          self.categories = []
8590 kshitij.so 12082 
          (_etype140, _size137) = iprot.readListBegin()
12083 
          for _i141 in xrange(_size137):
12084 
            _elem142 = iprot.readI64();
12085 
            self.categories.append(_elem142)
5944 mandeep.dh 12086 
          iprot.readListEnd()
12087 
        else:
12088 
          iprot.skip(ftype)
12089 
      else:
12090 
        iprot.skip(ftype)
12091 
      iprot.readFieldEnd()
12092 
    iprot.readStructEnd()
12093 
 
12094 
  def write(self, oprot):
12095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12097 
      return
12098 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
12099 
    if self.beginIndex is not None:
12100 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12101 
      oprot.writeI64(self.beginIndex)
12102 
      oprot.writeFieldEnd()
12103 
    if self.totalItems is not None:
12104 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12105 
      oprot.writeI64(self.totalItems)
12106 
      oprot.writeFieldEnd()
12107 
    if self.brand is not None:
12108 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
12109 
      oprot.writeString(self.brand)
12110 
      oprot.writeFieldEnd()
12111 
    if self.categories is not None:
12112 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
12113 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 12114 
      for iter143 in self.categories:
12115 
        oprot.writeI64(iter143)
5944 mandeep.dh 12116 
      oprot.writeListEnd()
12117 
      oprot.writeFieldEnd()
12118 
    oprot.writeFieldStop()
12119 
    oprot.writeStructEnd()
12120 
 
12121 
  def validate(self):
12122 
    return
12123 
 
12124 
 
12125 
  def __repr__(self):
12126 
    L = ['%s=%r' % (key, value)
12127 
      for key, value in self.__dict__.iteritems()]
12128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12129 
 
12130 
  def __eq__(self, other):
12131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12132 
 
12133 
  def __ne__(self, other):
12134 
    return not (self == other)
12135 
 
12136 
class getLatestArrivalsCatalogIds_result:
12137 
  """
12138 
  Attributes:
12139 
   - success
12140 
   - cex
12141 
  """
12142 
 
12143 
  thrift_spec = (
12144 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12145 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12146 
  )
12147 
 
12148 
  def __init__(self, success=None, cex=None,):
12149 
    self.success = success
12150 
    self.cex = cex
12151 
 
12152 
  def read(self, iprot):
12153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12155 
      return
12156 
    iprot.readStructBegin()
12157 
    while True:
12158 
      (fname, ftype, fid) = iprot.readFieldBegin()
12159 
      if ftype == TType.STOP:
12160 
        break
12161 
      if fid == 0:
12162 
        if ftype == TType.LIST:
12163 
          self.success = []
8590 kshitij.so 12164 
          (_etype147, _size144) = iprot.readListBegin()
12165 
          for _i148 in xrange(_size144):
12166 
            _elem149 = iprot.readI64();
12167 
            self.success.append(_elem149)
5944 mandeep.dh 12168 
          iprot.readListEnd()
12169 
        else:
12170 
          iprot.skip(ftype)
12171 
      elif fid == 1:
12172 
        if ftype == TType.STRUCT:
12173 
          self.cex = CatalogServiceException()
12174 
          self.cex.read(iprot)
12175 
        else:
12176 
          iprot.skip(ftype)
12177 
      else:
12178 
        iprot.skip(ftype)
12179 
      iprot.readFieldEnd()
12180 
    iprot.readStructEnd()
12181 
 
12182 
  def write(self, oprot):
12183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12185 
      return
12186 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
12187 
    if self.success is not None:
12188 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12189 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12190 
      for iter150 in self.success:
12191 
        oprot.writeI64(iter150)
5944 mandeep.dh 12192 
      oprot.writeListEnd()
12193 
      oprot.writeFieldEnd()
12194 
    if self.cex is not None:
12195 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12196 
      self.cex.write(oprot)
12197 
      oprot.writeFieldEnd()
12198 
    oprot.writeFieldStop()
12199 
    oprot.writeStructEnd()
12200 
 
12201 
  def validate(self):
12202 
    return
12203 
 
12204 
 
12205 
  def __repr__(self):
12206 
    L = ['%s=%r' % (key, value)
12207 
      for key, value in self.__dict__.iteritems()]
12208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12209 
 
12210 
  def __eq__(self, other):
12211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12212 
 
12213 
  def __ne__(self, other):
12214 
    return not (self == other)
12215 
 
12216 
class getLatestArrivalsCount_args:
12217 
 
12218 
  thrift_spec = (
12219 
  )
12220 
 
12221 
  def read(self, iprot):
12222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12224 
      return
12225 
    iprot.readStructBegin()
12226 
    while True:
12227 
      (fname, ftype, fid) = iprot.readFieldBegin()
12228 
      if ftype == TType.STOP:
12229 
        break
12230 
      else:
12231 
        iprot.skip(ftype)
12232 
      iprot.readFieldEnd()
12233 
    iprot.readStructEnd()
12234 
 
12235 
  def write(self, oprot):
12236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12238 
      return
12239 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
12240 
    oprot.writeFieldStop()
12241 
    oprot.writeStructEnd()
12242 
 
12243 
  def validate(self):
12244 
    return
12245 
 
12246 
 
12247 
  def __repr__(self):
12248 
    L = ['%s=%r' % (key, value)
12249 
      for key, value in self.__dict__.iteritems()]
12250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12251 
 
12252 
  def __eq__(self, other):
12253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12254 
 
12255 
  def __ne__(self, other):
12256 
    return not (self == other)
12257 
 
12258 
class getLatestArrivalsCount_result:
12259 
  """
12260 
  Attributes:
12261 
   - success
12262 
   - cex
12263 
  """
12264 
 
12265 
  thrift_spec = (
12266 
    (0, TType.I64, 'success', None, None, ), # 0
12267 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12268 
  )
12269 
 
12270 
  def __init__(self, success=None, cex=None,):
12271 
    self.success = success
12272 
    self.cex = cex
12273 
 
12274 
  def read(self, iprot):
12275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12277 
      return
12278 
    iprot.readStructBegin()
12279 
    while True:
12280 
      (fname, ftype, fid) = iprot.readFieldBegin()
12281 
      if ftype == TType.STOP:
12282 
        break
12283 
      if fid == 0:
12284 
        if ftype == TType.I64:
12285 
          self.success = iprot.readI64();
12286 
        else:
12287 
          iprot.skip(ftype)
12288 
      elif fid == 1:
12289 
        if ftype == TType.STRUCT:
12290 
          self.cex = CatalogServiceException()
12291 
          self.cex.read(iprot)
12292 
        else:
12293 
          iprot.skip(ftype)
12294 
      else:
12295 
        iprot.skip(ftype)
12296 
      iprot.readFieldEnd()
12297 
    iprot.readStructEnd()
12298 
 
12299 
  def write(self, oprot):
12300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12302 
      return
12303 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
12304 
    if self.success is not None:
12305 
      oprot.writeFieldBegin('success', TType.I64, 0)
12306 
      oprot.writeI64(self.success)
12307 
      oprot.writeFieldEnd()
12308 
    if self.cex is not None:
12309 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12310 
      self.cex.write(oprot)
12311 
      oprot.writeFieldEnd()
12312 
    oprot.writeFieldStop()
12313 
    oprot.writeStructEnd()
12314 
 
12315 
  def validate(self):
12316 
    return
12317 
 
12318 
 
12319 
  def __repr__(self):
12320 
    L = ['%s=%r' % (key, value)
12321 
      for key, value in self.__dict__.iteritems()]
12322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12323 
 
12324 
  def __eq__(self, other):
12325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12326 
 
12327 
  def __ne__(self, other):
12328 
    return not (self == other)
12329 
 
12330 
class generateNewEntityID_args:
12331 
 
12332 
  thrift_spec = (
12333 
  )
12334 
 
12335 
  def read(self, iprot):
12336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12338 
      return
12339 
    iprot.readStructBegin()
12340 
    while True:
12341 
      (fname, ftype, fid) = iprot.readFieldBegin()
12342 
      if ftype == TType.STOP:
12343 
        break
12344 
      else:
12345 
        iprot.skip(ftype)
12346 
      iprot.readFieldEnd()
12347 
    iprot.readStructEnd()
12348 
 
12349 
  def write(self, oprot):
12350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12352 
      return
12353 
    oprot.writeStructBegin('generateNewEntityID_args')
12354 
    oprot.writeFieldStop()
12355 
    oprot.writeStructEnd()
12356 
 
12357 
  def validate(self):
12358 
    return
12359 
 
12360 
 
12361 
  def __repr__(self):
12362 
    L = ['%s=%r' % (key, value)
12363 
      for key, value in self.__dict__.iteritems()]
12364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12365 
 
12366 
  def __eq__(self, other):
12367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12368 
 
12369 
  def __ne__(self, other):
12370 
    return not (self == other)
12371 
 
12372 
class generateNewEntityID_result:
12373 
  """
12374 
  Attributes:
12375 
   - success
12376 
  """
12377 
 
12378 
  thrift_spec = (
12379 
    (0, TType.I64, 'success', None, None, ), # 0
12380 
  )
12381 
 
12382 
  def __init__(self, success=None,):
12383 
    self.success = success
12384 
 
12385 
  def read(self, iprot):
12386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12388 
      return
12389 
    iprot.readStructBegin()
12390 
    while True:
12391 
      (fname, ftype, fid) = iprot.readFieldBegin()
12392 
      if ftype == TType.STOP:
12393 
        break
12394 
      if fid == 0:
12395 
        if ftype == TType.I64:
12396 
          self.success = iprot.readI64();
12397 
        else:
12398 
          iprot.skip(ftype)
12399 
      else:
12400 
        iprot.skip(ftype)
12401 
      iprot.readFieldEnd()
12402 
    iprot.readStructEnd()
12403 
 
12404 
  def write(self, oprot):
12405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12407 
      return
12408 
    oprot.writeStructBegin('generateNewEntityID_result')
12409 
    if self.success is not None:
12410 
      oprot.writeFieldBegin('success', TType.I64, 0)
12411 
      oprot.writeI64(self.success)
12412 
      oprot.writeFieldEnd()
12413 
    oprot.writeFieldStop()
12414 
    oprot.writeStructEnd()
12415 
 
12416 
  def validate(self):
12417 
    return
12418 
 
12419 
 
12420 
  def __repr__(self):
12421 
    L = ['%s=%r' % (key, value)
12422 
      for key, value in self.__dict__.iteritems()]
12423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12424 
 
12425 
  def __eq__(self, other):
12426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12427 
 
12428 
  def __ne__(self, other):
12429 
    return not (self == other)
12430 
 
12431 
class addCategory_args:
12432 
  """
12433 
  Attributes:
12434 
   - category
12435 
  """
12436 
 
12437 
  thrift_spec = (
12438 
    None, # 0
12439 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
12440 
  )
12441 
 
12442 
  def __init__(self, category=None,):
12443 
    self.category = category
12444 
 
12445 
  def read(self, iprot):
12446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12448 
      return
12449 
    iprot.readStructBegin()
12450 
    while True:
12451 
      (fname, ftype, fid) = iprot.readFieldBegin()
12452 
      if ftype == TType.STOP:
12453 
        break
12454 
      if fid == 1:
12455 
        if ftype == TType.STRUCT:
12456 
          self.category = Category()
12457 
          self.category.read(iprot)
12458 
        else:
12459 
          iprot.skip(ftype)
12460 
      else:
12461 
        iprot.skip(ftype)
12462 
      iprot.readFieldEnd()
12463 
    iprot.readStructEnd()
12464 
 
12465 
  def write(self, oprot):
12466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12468 
      return
12469 
    oprot.writeStructBegin('addCategory_args')
12470 
    if self.category is not None:
12471 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
12472 
      self.category.write(oprot)
12473 
      oprot.writeFieldEnd()
12474 
    oprot.writeFieldStop()
12475 
    oprot.writeStructEnd()
12476 
 
12477 
  def validate(self):
12478 
    return
12479 
 
12480 
 
12481 
  def __repr__(self):
12482 
    L = ['%s=%r' % (key, value)
12483 
      for key, value in self.__dict__.iteritems()]
12484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12485 
 
12486 
  def __eq__(self, other):
12487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12488 
 
12489 
  def __ne__(self, other):
12490 
    return not (self == other)
12491 
 
12492 
class addCategory_result:
12493 
  """
12494 
  Attributes:
12495 
   - success
12496 
  """
12497 
 
12498 
  thrift_spec = (
12499 
    (0, TType.BOOL, 'success', None, None, ), # 0
12500 
  )
12501 
 
12502 
  def __init__(self, success=None,):
12503 
    self.success = success
12504 
 
12505 
  def read(self, iprot):
12506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12508 
      return
12509 
    iprot.readStructBegin()
12510 
    while True:
12511 
      (fname, ftype, fid) = iprot.readFieldBegin()
12512 
      if ftype == TType.STOP:
12513 
        break
12514 
      if fid == 0:
12515 
        if ftype == TType.BOOL:
12516 
          self.success = iprot.readBool();
12517 
        else:
12518 
          iprot.skip(ftype)
12519 
      else:
12520 
        iprot.skip(ftype)
12521 
      iprot.readFieldEnd()
12522 
    iprot.readStructEnd()
12523 
 
12524 
  def write(self, oprot):
12525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12527 
      return
12528 
    oprot.writeStructBegin('addCategory_result')
12529 
    if self.success is not None:
12530 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12531 
      oprot.writeBool(self.success)
12532 
      oprot.writeFieldEnd()
12533 
    oprot.writeFieldStop()
12534 
    oprot.writeStructEnd()
12535 
 
12536 
  def validate(self):
12537 
    return
12538 
 
12539 
 
12540 
  def __repr__(self):
12541 
    L = ['%s=%r' % (key, value)
12542 
      for key, value in self.__dict__.iteritems()]
12543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12544 
 
12545 
  def __eq__(self, other):
12546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12547 
 
12548 
  def __ne__(self, other):
12549 
    return not (self == other)
12550 
 
12551 
class getCategory_args:
12552 
  """
12553 
  Attributes:
12554 
   - id
12555 
  """
12556 
 
12557 
  thrift_spec = (
12558 
    None, # 0
12559 
    (1, TType.I64, 'id', None, None, ), # 1
12560 
  )
12561 
 
12562 
  def __init__(self, id=None,):
12563 
    self.id = id
12564 
 
12565 
  def read(self, iprot):
12566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12568 
      return
12569 
    iprot.readStructBegin()
12570 
    while True:
12571 
      (fname, ftype, fid) = iprot.readFieldBegin()
12572 
      if ftype == TType.STOP:
12573 
        break
12574 
      if fid == 1:
12575 
        if ftype == TType.I64:
12576 
          self.id = iprot.readI64();
12577 
        else:
12578 
          iprot.skip(ftype)
12579 
      else:
12580 
        iprot.skip(ftype)
12581 
      iprot.readFieldEnd()
12582 
    iprot.readStructEnd()
12583 
 
12584 
  def write(self, oprot):
12585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12587 
      return
12588 
    oprot.writeStructBegin('getCategory_args')
12589 
    if self.id is not None:
12590 
      oprot.writeFieldBegin('id', TType.I64, 1)
12591 
      oprot.writeI64(self.id)
12592 
      oprot.writeFieldEnd()
12593 
    oprot.writeFieldStop()
12594 
    oprot.writeStructEnd()
12595 
 
12596 
  def validate(self):
12597 
    return
12598 
 
12599 
 
12600 
  def __repr__(self):
12601 
    L = ['%s=%r' % (key, value)
12602 
      for key, value in self.__dict__.iteritems()]
12603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12604 
 
12605 
  def __eq__(self, other):
12606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12607 
 
12608 
  def __ne__(self, other):
12609 
    return not (self == other)
12610 
 
12611 
class getCategory_result:
12612 
  """
12613 
  Attributes:
12614 
   - success
12615 
  """
12616 
 
12617 
  thrift_spec = (
12618 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
12619 
  )
12620 
 
12621 
  def __init__(self, success=None,):
12622 
    self.success = success
12623 
 
12624 
  def read(self, iprot):
12625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12627 
      return
12628 
    iprot.readStructBegin()
12629 
    while True:
12630 
      (fname, ftype, fid) = iprot.readFieldBegin()
12631 
      if ftype == TType.STOP:
12632 
        break
12633 
      if fid == 0:
12634 
        if ftype == TType.STRUCT:
12635 
          self.success = Category()
12636 
          self.success.read(iprot)
12637 
        else:
12638 
          iprot.skip(ftype)
12639 
      else:
12640 
        iprot.skip(ftype)
12641 
      iprot.readFieldEnd()
12642 
    iprot.readStructEnd()
12643 
 
12644 
  def write(self, oprot):
12645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12647 
      return
12648 
    oprot.writeStructBegin('getCategory_result')
12649 
    if self.success is not None:
12650 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12651 
      self.success.write(oprot)
12652 
      oprot.writeFieldEnd()
12653 
    oprot.writeFieldStop()
12654 
    oprot.writeStructEnd()
12655 
 
12656 
  def validate(self):
12657 
    return
12658 
 
12659 
 
12660 
  def __repr__(self):
12661 
    L = ['%s=%r' % (key, value)
12662 
      for key, value in self.__dict__.iteritems()]
12663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12664 
 
12665 
  def __eq__(self, other):
12666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12667 
 
12668 
  def __ne__(self, other):
12669 
    return not (self == other)
12670 
 
12671 
class getAllCategories_args:
12672 
 
12673 
  thrift_spec = (
12674 
  )
12675 
 
12676 
  def read(self, iprot):
12677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12679 
      return
12680 
    iprot.readStructBegin()
12681 
    while True:
12682 
      (fname, ftype, fid) = iprot.readFieldBegin()
12683 
      if ftype == TType.STOP:
12684 
        break
12685 
      else:
12686 
        iprot.skip(ftype)
12687 
      iprot.readFieldEnd()
12688 
    iprot.readStructEnd()
12689 
 
12690 
  def write(self, oprot):
12691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12693 
      return
12694 
    oprot.writeStructBegin('getAllCategories_args')
12695 
    oprot.writeFieldStop()
12696 
    oprot.writeStructEnd()
12697 
 
12698 
  def validate(self):
12699 
    return
12700 
 
12701 
 
12702 
  def __repr__(self):
12703 
    L = ['%s=%r' % (key, value)
12704 
      for key, value in self.__dict__.iteritems()]
12705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12706 
 
12707 
  def __eq__(self, other):
12708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12709 
 
12710 
  def __ne__(self, other):
12711 
    return not (self == other)
12712 
 
12713 
class getAllCategories_result:
12714 
  """
12715 
  Attributes:
12716 
   - success
12717 
  """
12718 
 
12719 
  thrift_spec = (
12720 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
12721 
  )
12722 
 
12723 
  def __init__(self, success=None,):
12724 
    self.success = success
12725 
 
12726 
  def read(self, iprot):
12727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12729 
      return
12730 
    iprot.readStructBegin()
12731 
    while True:
12732 
      (fname, ftype, fid) = iprot.readFieldBegin()
12733 
      if ftype == TType.STOP:
12734 
        break
12735 
      if fid == 0:
12736 
        if ftype == TType.LIST:
12737 
          self.success = []
8590 kshitij.so 12738 
          (_etype154, _size151) = iprot.readListBegin()
12739 
          for _i155 in xrange(_size151):
12740 
            _elem156 = Category()
12741 
            _elem156.read(iprot)
12742 
            self.success.append(_elem156)
5944 mandeep.dh 12743 
          iprot.readListEnd()
12744 
        else:
12745 
          iprot.skip(ftype)
12746 
      else:
12747 
        iprot.skip(ftype)
12748 
      iprot.readFieldEnd()
12749 
    iprot.readStructEnd()
12750 
 
12751 
  def write(self, oprot):
12752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12754 
      return
12755 
    oprot.writeStructBegin('getAllCategories_result')
12756 
    if self.success is not None:
12757 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12758 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12759 
      for iter157 in self.success:
12760 
        iter157.write(oprot)
5944 mandeep.dh 12761 
      oprot.writeListEnd()
12762 
      oprot.writeFieldEnd()
12763 
    oprot.writeFieldStop()
12764 
    oprot.writeStructEnd()
12765 
 
12766 
  def validate(self):
12767 
    return
12768 
 
12769 
 
12770 
  def __repr__(self):
12771 
    L = ['%s=%r' % (key, value)
12772 
      for key, value in self.__dict__.iteritems()]
12773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12774 
 
12775 
  def __eq__(self, other):
12776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12777 
 
12778 
  def __ne__(self, other):
12779 
    return not (self == other)
12780 
 
12781 
class getAllSimilarItems_args:
12782 
  """
12783 
  Attributes:
12784 
   - itemId
12785 
  """
12786 
 
12787 
  thrift_spec = (
12788 
    None, # 0
12789 
    (1, TType.I64, 'itemId', None, None, ), # 1
12790 
  )
12791 
 
12792 
  def __init__(self, itemId=None,):
12793 
    self.itemId = itemId
12794 
 
12795 
  def read(self, iprot):
12796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12798 
      return
12799 
    iprot.readStructBegin()
12800 
    while True:
12801 
      (fname, ftype, fid) = iprot.readFieldBegin()
12802 
      if ftype == TType.STOP:
12803 
        break
12804 
      if fid == 1:
12805 
        if ftype == TType.I64:
12806 
          self.itemId = iprot.readI64();
12807 
        else:
12808 
          iprot.skip(ftype)
12809 
      else:
12810 
        iprot.skip(ftype)
12811 
      iprot.readFieldEnd()
12812 
    iprot.readStructEnd()
12813 
 
12814 
  def write(self, oprot):
12815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12817 
      return
12818 
    oprot.writeStructBegin('getAllSimilarItems_args')
12819 
    if self.itemId is not None:
12820 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12821 
      oprot.writeI64(self.itemId)
12822 
      oprot.writeFieldEnd()
12823 
    oprot.writeFieldStop()
12824 
    oprot.writeStructEnd()
12825 
 
12826 
  def validate(self):
12827 
    return
12828 
 
12829 
 
12830 
  def __repr__(self):
12831 
    L = ['%s=%r' % (key, value)
12832 
      for key, value in self.__dict__.iteritems()]
12833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12834 
 
12835 
  def __eq__(self, other):
12836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12837 
 
12838 
  def __ne__(self, other):
12839 
    return not (self == other)
12840 
 
12841 
class getAllSimilarItems_result:
12842 
  """
12843 
  Attributes:
12844 
   - success
12845 
  """
12846 
 
12847 
  thrift_spec = (
12848 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12849 
  )
12850 
 
12851 
  def __init__(self, success=None,):
12852 
    self.success = success
12853 
 
12854 
  def read(self, iprot):
12855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12857 
      return
12858 
    iprot.readStructBegin()
12859 
    while True:
12860 
      (fname, ftype, fid) = iprot.readFieldBegin()
12861 
      if ftype == TType.STOP:
12862 
        break
12863 
      if fid == 0:
12864 
        if ftype == TType.LIST:
12865 
          self.success = []
8590 kshitij.so 12866 
          (_etype161, _size158) = iprot.readListBegin()
12867 
          for _i162 in xrange(_size158):
12868 
            _elem163 = Item()
12869 
            _elem163.read(iprot)
12870 
            self.success.append(_elem163)
5944 mandeep.dh 12871 
          iprot.readListEnd()
12872 
        else:
12873 
          iprot.skip(ftype)
12874 
      else:
12875 
        iprot.skip(ftype)
12876 
      iprot.readFieldEnd()
12877 
    iprot.readStructEnd()
12878 
 
12879 
  def write(self, oprot):
12880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12882 
      return
12883 
    oprot.writeStructBegin('getAllSimilarItems_result')
12884 
    if self.success is not None:
12885 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12886 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12887 
      for iter164 in self.success:
12888 
        iter164.write(oprot)
5944 mandeep.dh 12889 
      oprot.writeListEnd()
12890 
      oprot.writeFieldEnd()
12891 
    oprot.writeFieldStop()
12892 
    oprot.writeStructEnd()
12893 
 
12894 
  def validate(self):
12895 
    return
12896 
 
12897 
 
12898 
  def __repr__(self):
12899 
    L = ['%s=%r' % (key, value)
12900 
      for key, value in self.__dict__.iteritems()]
12901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12902 
 
12903 
  def __eq__(self, other):
12904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12905 
 
12906 
  def __ne__(self, other):
12907 
    return not (self == other)
12908 
 
12909 
class addSimilarItem_args:
12910 
  """
12911 
  Attributes:
12912 
   - itemId
12913 
   - catalogItemId
12914 
  """
12915 
 
12916 
  thrift_spec = (
12917 
    None, # 0
12918 
    (1, TType.I64, 'itemId', None, None, ), # 1
12919 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
12920 
  )
12921 
 
12922 
  def __init__(self, itemId=None, catalogItemId=None,):
12923 
    self.itemId = itemId
12924 
    self.catalogItemId = catalogItemId
12925 
 
12926 
  def read(self, iprot):
12927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12929 
      return
12930 
    iprot.readStructBegin()
12931 
    while True:
12932 
      (fname, ftype, fid) = iprot.readFieldBegin()
12933 
      if ftype == TType.STOP:
12934 
        break
12935 
      if fid == 1:
12936 
        if ftype == TType.I64:
12937 
          self.itemId = iprot.readI64();
12938 
        else:
12939 
          iprot.skip(ftype)
12940 
      elif fid == 2:
12941 
        if ftype == TType.I64:
12942 
          self.catalogItemId = iprot.readI64();
12943 
        else:
12944 
          iprot.skip(ftype)
12945 
      else:
12946 
        iprot.skip(ftype)
12947 
      iprot.readFieldEnd()
12948 
    iprot.readStructEnd()
12949 
 
12950 
  def write(self, oprot):
12951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12953 
      return
12954 
    oprot.writeStructBegin('addSimilarItem_args')
12955 
    if self.itemId is not None:
12956 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12957 
      oprot.writeI64(self.itemId)
12958 
      oprot.writeFieldEnd()
12959 
    if self.catalogItemId is not None:
12960 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
12961 
      oprot.writeI64(self.catalogItemId)
12962 
      oprot.writeFieldEnd()
12963 
    oprot.writeFieldStop()
12964 
    oprot.writeStructEnd()
12965 
 
12966 
  def validate(self):
12967 
    return
12968 
 
12969 
 
12970 
  def __repr__(self):
12971 
    L = ['%s=%r' % (key, value)
12972 
      for key, value in self.__dict__.iteritems()]
12973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12974 
 
12975 
  def __eq__(self, other):
12976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12977 
 
12978 
  def __ne__(self, other):
12979 
    return not (self == other)
12980 
 
12981 
class addSimilarItem_result:
12982 
  """
12983 
  Attributes:
12984 
   - success
12985 
   - cex
12986 
  """
12987 
 
12988 
  thrift_spec = (
12989 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
12990 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12991 
  )
12992 
 
12993 
  def __init__(self, success=None, cex=None,):
12994 
    self.success = success
12995 
    self.cex = cex
12996 
 
12997 
  def read(self, iprot):
12998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13000 
      return
13001 
    iprot.readStructBegin()
13002 
    while True:
13003 
      (fname, ftype, fid) = iprot.readFieldBegin()
13004 
      if ftype == TType.STOP:
13005 
        break
13006 
      if fid == 0:
13007 
        if ftype == TType.STRUCT:
13008 
          self.success = Item()
13009 
          self.success.read(iprot)
13010 
        else:
13011 
          iprot.skip(ftype)
13012 
      elif fid == 1:
13013 
        if ftype == TType.STRUCT:
13014 
          self.cex = CatalogServiceException()
13015 
          self.cex.read(iprot)
13016 
        else:
13017 
          iprot.skip(ftype)
13018 
      else:
13019 
        iprot.skip(ftype)
13020 
      iprot.readFieldEnd()
13021 
    iprot.readStructEnd()
13022 
 
13023 
  def write(self, oprot):
13024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13026 
      return
13027 
    oprot.writeStructBegin('addSimilarItem_result')
13028 
    if self.success is not None:
13029 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13030 
      self.success.write(oprot)
13031 
      oprot.writeFieldEnd()
13032 
    if self.cex is not None:
13033 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13034 
      self.cex.write(oprot)
13035 
      oprot.writeFieldEnd()
13036 
    oprot.writeFieldStop()
13037 
    oprot.writeStructEnd()
13038 
 
13039 
  def validate(self):
13040 
    return
13041 
 
13042 
 
13043 
  def __repr__(self):
13044 
    L = ['%s=%r' % (key, value)
13045 
      for key, value in self.__dict__.iteritems()]
13046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13047 
 
13048 
  def __eq__(self, other):
13049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13050 
 
13051 
  def __ne__(self, other):
13052 
    return not (self == other)
13053 
 
6512 kshitij.so 13054 
class addTag_args:
13055 
  """
13056 
  Attributes:
13057 
   - displayName
13058 
   - itemId
13059 
  """
13060 
 
13061 
  thrift_spec = (
13062 
    None, # 0
13063 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13064 
    (2, TType.I64, 'itemId', None, None, ), # 2
13065 
  )
13066 
 
13067 
  def __init__(self, displayName=None, itemId=None,):
13068 
    self.displayName = displayName
13069 
    self.itemId = itemId
13070 
 
13071 
  def read(self, iprot):
13072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13074 
      return
13075 
    iprot.readStructBegin()
13076 
    while True:
13077 
      (fname, ftype, fid) = iprot.readFieldBegin()
13078 
      if ftype == TType.STOP:
13079 
        break
13080 
      if fid == 1:
13081 
        if ftype == TType.STRING:
13082 
          self.displayName = iprot.readString();
13083 
        else:
13084 
          iprot.skip(ftype)
13085 
      elif fid == 2:
13086 
        if ftype == TType.I64:
13087 
          self.itemId = iprot.readI64();
13088 
        else:
13089 
          iprot.skip(ftype)
13090 
      else:
13091 
        iprot.skip(ftype)
13092 
      iprot.readFieldEnd()
13093 
    iprot.readStructEnd()
13094 
 
13095 
  def write(self, oprot):
13096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13098 
      return
13099 
    oprot.writeStructBegin('addTag_args')
13100 
    if self.displayName is not None:
13101 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13102 
      oprot.writeString(self.displayName)
13103 
      oprot.writeFieldEnd()
13104 
    if self.itemId is not None:
13105 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13106 
      oprot.writeI64(self.itemId)
13107 
      oprot.writeFieldEnd()
13108 
    oprot.writeFieldStop()
13109 
    oprot.writeStructEnd()
13110 
 
13111 
  def validate(self):
13112 
    return
13113 
 
13114 
 
13115 
  def __repr__(self):
13116 
    L = ['%s=%r' % (key, value)
13117 
      for key, value in self.__dict__.iteritems()]
13118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13119 
 
13120 
  def __eq__(self, other):
13121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13122 
 
13123 
  def __ne__(self, other):
13124 
    return not (self == other)
13125 
 
13126 
class addTag_result:
13127 
  """
13128 
  Attributes:
13129 
   - success
13130 
  """
13131 
 
13132 
  thrift_spec = (
13133 
    (0, TType.BOOL, 'success', None, None, ), # 0
13134 
  )
13135 
 
13136 
  def __init__(self, success=None,):
13137 
    self.success = success
13138 
 
13139 
  def read(self, iprot):
13140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13142 
      return
13143 
    iprot.readStructBegin()
13144 
    while True:
13145 
      (fname, ftype, fid) = iprot.readFieldBegin()
13146 
      if ftype == TType.STOP:
13147 
        break
13148 
      if fid == 0:
13149 
        if ftype == TType.BOOL:
13150 
          self.success = iprot.readBool();
13151 
        else:
13152 
          iprot.skip(ftype)
13153 
      else:
13154 
        iprot.skip(ftype)
13155 
      iprot.readFieldEnd()
13156 
    iprot.readStructEnd()
13157 
 
13158 
  def write(self, oprot):
13159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13161 
      return
13162 
    oprot.writeStructBegin('addTag_result')
13163 
    if self.success is not None:
13164 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13165 
      oprot.writeBool(self.success)
13166 
      oprot.writeFieldEnd()
13167 
    oprot.writeFieldStop()
13168 
    oprot.writeStructEnd()
13169 
 
13170 
  def validate(self):
13171 
    return
13172 
 
13173 
 
13174 
  def __repr__(self):
13175 
    L = ['%s=%r' % (key, value)
13176 
      for key, value in self.__dict__.iteritems()]
13177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13178 
 
13179 
  def __eq__(self, other):
13180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13181 
 
13182 
  def __ne__(self, other):
13183 
    return not (self == other)
13184 
 
13185 
class deleteEntityTag_args:
13186 
  """
13187 
  Attributes:
13188 
   - displayName
13189 
   - itemId
13190 
  """
13191 
 
13192 
  thrift_spec = (
13193 
    None, # 0
13194 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13195 
    (2, TType.I64, 'itemId', None, None, ), # 2
13196 
  )
13197 
 
13198 
  def __init__(self, displayName=None, itemId=None,):
13199 
    self.displayName = displayName
13200 
    self.itemId = itemId
13201 
 
13202 
  def read(self, iprot):
13203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13205 
      return
13206 
    iprot.readStructBegin()
13207 
    while True:
13208 
      (fname, ftype, fid) = iprot.readFieldBegin()
13209 
      if ftype == TType.STOP:
13210 
        break
13211 
      if fid == 1:
13212 
        if ftype == TType.STRING:
13213 
          self.displayName = iprot.readString();
13214 
        else:
13215 
          iprot.skip(ftype)
13216 
      elif fid == 2:
13217 
        if ftype == TType.I64:
13218 
          self.itemId = iprot.readI64();
13219 
        else:
13220 
          iprot.skip(ftype)
13221 
      else:
13222 
        iprot.skip(ftype)
13223 
      iprot.readFieldEnd()
13224 
    iprot.readStructEnd()
13225 
 
13226 
  def write(self, oprot):
13227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13229 
      return
13230 
    oprot.writeStructBegin('deleteEntityTag_args')
13231 
    if self.displayName is not None:
13232 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13233 
      oprot.writeString(self.displayName)
13234 
      oprot.writeFieldEnd()
13235 
    if self.itemId is not None:
13236 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13237 
      oprot.writeI64(self.itemId)
13238 
      oprot.writeFieldEnd()
13239 
    oprot.writeFieldStop()
13240 
    oprot.writeStructEnd()
13241 
 
13242 
  def validate(self):
13243 
    return
13244 
 
13245 
 
13246 
  def __repr__(self):
13247 
    L = ['%s=%r' % (key, value)
13248 
      for key, value in self.__dict__.iteritems()]
13249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13250 
 
13251 
  def __eq__(self, other):
13252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13253 
 
13254 
  def __ne__(self, other):
13255 
    return not (self == other)
13256 
 
13257 
class deleteEntityTag_result:
13258 
  """
13259 
  Attributes:
13260 
   - success
13261 
  """
13262 
 
13263 
  thrift_spec = (
13264 
    (0, TType.BOOL, 'success', None, None, ), # 0
13265 
  )
13266 
 
13267 
  def __init__(self, success=None,):
13268 
    self.success = success
13269 
 
13270 
  def read(self, iprot):
13271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13273 
      return
13274 
    iprot.readStructBegin()
13275 
    while True:
13276 
      (fname, ftype, fid) = iprot.readFieldBegin()
13277 
      if ftype == TType.STOP:
13278 
        break
13279 
      if fid == 0:
13280 
        if ftype == TType.BOOL:
13281 
          self.success = iprot.readBool();
13282 
        else:
13283 
          iprot.skip(ftype)
13284 
      else:
13285 
        iprot.skip(ftype)
13286 
      iprot.readFieldEnd()
13287 
    iprot.readStructEnd()
13288 
 
13289 
  def write(self, oprot):
13290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13292 
      return
13293 
    oprot.writeStructBegin('deleteEntityTag_result')
13294 
    if self.success is not None:
13295 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13296 
      oprot.writeBool(self.success)
13297 
      oprot.writeFieldEnd()
13298 
    oprot.writeFieldStop()
13299 
    oprot.writeStructEnd()
13300 
 
13301 
  def validate(self):
13302 
    return
13303 
 
13304 
 
13305 
  def __repr__(self):
13306 
    L = ['%s=%r' % (key, value)
13307 
      for key, value in self.__dict__.iteritems()]
13308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13309 
 
13310 
  def __eq__(self, other):
13311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13312 
 
13313 
  def __ne__(self, other):
13314 
    return not (self == other)
13315 
 
13316 
class deleteTag_args:
13317 
  """
13318 
  Attributes:
13319 
   - displayName
13320 
  """
13321 
 
13322 
  thrift_spec = (
13323 
    None, # 0
13324 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13325 
  )
13326 
 
13327 
  def __init__(self, displayName=None,):
13328 
    self.displayName = displayName
13329 
 
13330 
  def read(self, iprot):
13331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13333 
      return
13334 
    iprot.readStructBegin()
13335 
    while True:
13336 
      (fname, ftype, fid) = iprot.readFieldBegin()
13337 
      if ftype == TType.STOP:
13338 
        break
13339 
      if fid == 1:
13340 
        if ftype == TType.STRING:
13341 
          self.displayName = iprot.readString();
13342 
        else:
13343 
          iprot.skip(ftype)
13344 
      else:
13345 
        iprot.skip(ftype)
13346 
      iprot.readFieldEnd()
13347 
    iprot.readStructEnd()
13348 
 
13349 
  def write(self, oprot):
13350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13352 
      return
13353 
    oprot.writeStructBegin('deleteTag_args')
13354 
    if self.displayName is not None:
13355 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13356 
      oprot.writeString(self.displayName)
13357 
      oprot.writeFieldEnd()
13358 
    oprot.writeFieldStop()
13359 
    oprot.writeStructEnd()
13360 
 
13361 
  def validate(self):
13362 
    return
13363 
 
13364 
 
13365 
  def __repr__(self):
13366 
    L = ['%s=%r' % (key, value)
13367 
      for key, value in self.__dict__.iteritems()]
13368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13369 
 
13370 
  def __eq__(self, other):
13371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13372 
 
13373 
  def __ne__(self, other):
13374 
    return not (self == other)
13375 
 
13376 
class deleteTag_result:
13377 
  """
13378 
  Attributes:
13379 
   - success
13380 
  """
13381 
 
13382 
  thrift_spec = (
13383 
    (0, TType.BOOL, 'success', None, None, ), # 0
13384 
  )
13385 
 
13386 
  def __init__(self, success=None,):
13387 
    self.success = success
13388 
 
13389 
  def read(self, iprot):
13390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13392 
      return
13393 
    iprot.readStructBegin()
13394 
    while True:
13395 
      (fname, ftype, fid) = iprot.readFieldBegin()
13396 
      if ftype == TType.STOP:
13397 
        break
13398 
      if fid == 0:
13399 
        if ftype == TType.BOOL:
13400 
          self.success = iprot.readBool();
13401 
        else:
13402 
          iprot.skip(ftype)
13403 
      else:
13404 
        iprot.skip(ftype)
13405 
      iprot.readFieldEnd()
13406 
    iprot.readStructEnd()
13407 
 
13408 
  def write(self, oprot):
13409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13411 
      return
13412 
    oprot.writeStructBegin('deleteTag_result')
13413 
    if self.success is not None:
13414 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13415 
      oprot.writeBool(self.success)
13416 
      oprot.writeFieldEnd()
13417 
    oprot.writeFieldStop()
13418 
    oprot.writeStructEnd()
13419 
 
13420 
  def validate(self):
13421 
    return
13422 
 
13423 
 
13424 
  def __repr__(self):
13425 
    L = ['%s=%r' % (key, value)
13426 
      for key, value in self.__dict__.iteritems()]
13427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13428 
 
13429 
  def __eq__(self, other):
13430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13431 
 
13432 
  def __ne__(self, other):
13433 
    return not (self == other)
13434 
 
13435 
class getAllTags_args:
13436 
 
13437 
  thrift_spec = (
13438 
  )
13439 
 
13440 
  def read(self, iprot):
13441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13443 
      return
13444 
    iprot.readStructBegin()
13445 
    while True:
13446 
      (fname, ftype, fid) = iprot.readFieldBegin()
13447 
      if ftype == TType.STOP:
13448 
        break
13449 
      else:
13450 
        iprot.skip(ftype)
13451 
      iprot.readFieldEnd()
13452 
    iprot.readStructEnd()
13453 
 
13454 
  def write(self, oprot):
13455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13457 
      return
13458 
    oprot.writeStructBegin('getAllTags_args')
13459 
    oprot.writeFieldStop()
13460 
    oprot.writeStructEnd()
13461 
 
13462 
  def validate(self):
13463 
    return
13464 
 
13465 
 
13466 
  def __repr__(self):
13467 
    L = ['%s=%r' % (key, value)
13468 
      for key, value in self.__dict__.iteritems()]
13469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13470 
 
13471 
  def __eq__(self, other):
13472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13473 
 
13474 
  def __ne__(self, other):
13475 
    return not (self == other)
13476 
 
13477 
class getAllTags_result:
13478 
  """
13479 
  Attributes:
13480 
   - success
13481 
  """
13482 
 
13483 
  thrift_spec = (
13484 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13485 
  )
13486 
 
13487 
  def __init__(self, success=None,):
13488 
    self.success = success
13489 
 
13490 
  def read(self, iprot):
13491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13493 
      return
13494 
    iprot.readStructBegin()
13495 
    while True:
13496 
      (fname, ftype, fid) = iprot.readFieldBegin()
13497 
      if ftype == TType.STOP:
13498 
        break
13499 
      if fid == 0:
13500 
        if ftype == TType.LIST:
13501 
          self.success = []
8590 kshitij.so 13502 
          (_etype168, _size165) = iprot.readListBegin()
13503 
          for _i169 in xrange(_size165):
13504 
            _elem170 = iprot.readString();
13505 
            self.success.append(_elem170)
6512 kshitij.so 13506 
          iprot.readListEnd()
13507 
        else:
13508 
          iprot.skip(ftype)
13509 
      else:
13510 
        iprot.skip(ftype)
13511 
      iprot.readFieldEnd()
13512 
    iprot.readStructEnd()
13513 
 
13514 
  def write(self, oprot):
13515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13517 
      return
13518 
    oprot.writeStructBegin('getAllTags_result')
13519 
    if self.success is not None:
13520 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13521 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 13522 
      for iter171 in self.success:
13523 
        oprot.writeString(iter171)
6512 kshitij.so 13524 
      oprot.writeListEnd()
13525 
      oprot.writeFieldEnd()
13526 
    oprot.writeFieldStop()
13527 
    oprot.writeStructEnd()
13528 
 
13529 
  def validate(self):
13530 
    return
13531 
 
13532 
 
13533 
  def __repr__(self):
13534 
    L = ['%s=%r' % (key, value)
13535 
      for key, value in self.__dict__.iteritems()]
13536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13537 
 
13538 
  def __eq__(self, other):
13539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13540 
 
13541 
  def __ne__(self, other):
13542 
    return not (self == other)
13543 
 
13544 
class getAllEntitiesByTagName_args:
13545 
  """
13546 
  Attributes:
13547 
   - displayName
13548 
  """
13549 
 
13550 
  thrift_spec = (
13551 
    None, # 0
13552 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13553 
  )
13554 
 
13555 
  def __init__(self, displayName=None,):
13556 
    self.displayName = displayName
13557 
 
13558 
  def read(self, iprot):
13559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13561 
      return
13562 
    iprot.readStructBegin()
13563 
    while True:
13564 
      (fname, ftype, fid) = iprot.readFieldBegin()
13565 
      if ftype == TType.STOP:
13566 
        break
13567 
      if fid == 1:
13568 
        if ftype == TType.STRING:
13569 
          self.displayName = iprot.readString();
13570 
        else:
13571 
          iprot.skip(ftype)
13572 
      else:
13573 
        iprot.skip(ftype)
13574 
      iprot.readFieldEnd()
13575 
    iprot.readStructEnd()
13576 
 
13577 
  def write(self, oprot):
13578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13580 
      return
13581 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
13582 
    if self.displayName is not None:
13583 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13584 
      oprot.writeString(self.displayName)
13585 
      oprot.writeFieldEnd()
13586 
    oprot.writeFieldStop()
13587 
    oprot.writeStructEnd()
13588 
 
13589 
  def validate(self):
13590 
    return
13591 
 
13592 
 
13593 
  def __repr__(self):
13594 
    L = ['%s=%r' % (key, value)
13595 
      for key, value in self.__dict__.iteritems()]
13596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13597 
 
13598 
  def __eq__(self, other):
13599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13600 
 
13601 
  def __ne__(self, other):
13602 
    return not (self == other)
13603 
 
13604 
class getAllEntitiesByTagName_result:
13605 
  """
13606 
  Attributes:
13607 
   - success
13608 
  """
13609 
 
13610 
  thrift_spec = (
13611 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13612 
  )
13613 
 
13614 
  def __init__(self, success=None,):
13615 
    self.success = success
13616 
 
13617 
  def read(self, iprot):
13618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13620 
      return
13621 
    iprot.readStructBegin()
13622 
    while True:
13623 
      (fname, ftype, fid) = iprot.readFieldBegin()
13624 
      if ftype == TType.STOP:
13625 
        break
13626 
      if fid == 0:
13627 
        if ftype == TType.LIST:
13628 
          self.success = []
8590 kshitij.so 13629 
          (_etype175, _size172) = iprot.readListBegin()
13630 
          for _i176 in xrange(_size172):
13631 
            _elem177 = iprot.readI64();
13632 
            self.success.append(_elem177)
6512 kshitij.so 13633 
          iprot.readListEnd()
13634 
        else:
13635 
          iprot.skip(ftype)
13636 
      else:
13637 
        iprot.skip(ftype)
13638 
      iprot.readFieldEnd()
13639 
    iprot.readStructEnd()
13640 
 
13641 
  def write(self, oprot):
13642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13644 
      return
13645 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
13646 
    if self.success is not None:
13647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13648 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 13649 
      for iter178 in self.success:
13650 
        oprot.writeI64(iter178)
6512 kshitij.so 13651 
      oprot.writeListEnd()
13652 
      oprot.writeFieldEnd()
13653 
    oprot.writeFieldStop()
13654 
    oprot.writeStructEnd()
13655 
 
13656 
  def validate(self):
13657 
    return
13658 
 
13659 
 
13660 
  def __repr__(self):
13661 
    L = ['%s=%r' % (key, value)
13662 
      for key, value in self.__dict__.iteritems()]
13663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13664 
 
13665 
  def __eq__(self, other):
13666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13667 
 
13668 
  def __ne__(self, other):
13669 
    return not (self == other)
13670 
 
6845 amit.gupta 13671 
class getAllEntityTags_args:
13672 
 
13673 
  thrift_spec = (
13674 
  )
13675 
 
13676 
  def read(self, iprot):
13677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13679 
      return
13680 
    iprot.readStructBegin()
13681 
    while True:
13682 
      (fname, ftype, fid) = iprot.readFieldBegin()
13683 
      if ftype == TType.STOP:
13684 
        break
13685 
      else:
13686 
        iprot.skip(ftype)
13687 
      iprot.readFieldEnd()
13688 
    iprot.readStructEnd()
13689 
 
13690 
  def write(self, oprot):
13691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13693 
      return
13694 
    oprot.writeStructBegin('getAllEntityTags_args')
13695 
    oprot.writeFieldStop()
13696 
    oprot.writeStructEnd()
13697 
 
13698 
  def validate(self):
13699 
    return
13700 
 
13701 
 
13702 
  def __repr__(self):
13703 
    L = ['%s=%r' % (key, value)
13704 
      for key, value in self.__dict__.iteritems()]
13705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13706 
 
13707 
  def __eq__(self, other):
13708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13709 
 
13710 
  def __ne__(self, other):
13711 
    return not (self == other)
13712 
 
13713 
class getAllEntityTags_result:
13714 
  """
13715 
  Attributes:
13716 
   - success
13717 
  """
13718 
 
13719 
  thrift_spec = (
13720 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
13721 
  )
13722 
 
13723 
  def __init__(self, success=None,):
13724 
    self.success = success
13725 
 
13726 
  def read(self, iprot):
13727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13729 
      return
13730 
    iprot.readStructBegin()
13731 
    while True:
13732 
      (fname, ftype, fid) = iprot.readFieldBegin()
13733 
      if ftype == TType.STOP:
13734 
        break
13735 
      if fid == 0:
13736 
        if ftype == TType.MAP:
13737 
          self.success = {}
8590 kshitij.so 13738 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
13739 
          for _i183 in xrange(_size179):
13740 
            _key184 = iprot.readI64();
13741 
            _val185 = []
13742 
            (_etype189, _size186) = iprot.readListBegin()
13743 
            for _i190 in xrange(_size186):
13744 
              _elem191 = iprot.readString();
13745 
              _val185.append(_elem191)
6845 amit.gupta 13746 
            iprot.readListEnd()
8590 kshitij.so 13747 
            self.success[_key184] = _val185
6845 amit.gupta 13748 
          iprot.readMapEnd()
13749 
        else:
13750 
          iprot.skip(ftype)
13751 
      else:
13752 
        iprot.skip(ftype)
13753 
      iprot.readFieldEnd()
13754 
    iprot.readStructEnd()
13755 
 
13756 
  def write(self, oprot):
13757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13759 
      return
13760 
    oprot.writeStructBegin('getAllEntityTags_result')
13761 
    if self.success is not None:
13762 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13763 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 13764 
      for kiter192,viter193 in self.success.items():
13765 
        oprot.writeI64(kiter192)
13766 
        oprot.writeListBegin(TType.STRING, len(viter193))
13767 
        for iter194 in viter193:
13768 
          oprot.writeString(iter194)
6845 amit.gupta 13769 
        oprot.writeListEnd()
13770 
      oprot.writeMapEnd()
13771 
      oprot.writeFieldEnd()
13772 
    oprot.writeFieldStop()
13773 
    oprot.writeStructEnd()
13774 
 
13775 
  def validate(self):
13776 
    return
13777 
 
13778 
 
13779 
  def __repr__(self):
13780 
    L = ['%s=%r' % (key, value)
13781 
      for key, value in self.__dict__.iteritems()]
13782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13783 
 
13784 
  def __eq__(self, other):
13785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13786 
 
13787 
  def __ne__(self, other):
13788 
    return not (self == other)
13789 
 
6850 kshitij.so 13790 
class addBanner_args:
13791 
  """
13792 
  Attributes:
8590 kshitij.so 13793 
   - bannerCongregate
6850 kshitij.so 13794 
  """
13795 
 
13796 
  thrift_spec = (
13797 
    None, # 0
8590 kshitij.so 13798 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 13799 
  )
13800 
 
8590 kshitij.so 13801 
  def __init__(self, bannerCongregate=None,):
13802 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 13803 
 
13804 
  def read(self, iprot):
13805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13807 
      return
13808 
    iprot.readStructBegin()
13809 
    while True:
13810 
      (fname, ftype, fid) = iprot.readFieldBegin()
13811 
      if ftype == TType.STOP:
13812 
        break
13813 
      if fid == 1:
8579 kshitij.so 13814 
        if ftype == TType.STRUCT:
8590 kshitij.so 13815 
          self.bannerCongregate = BannerCongregate()
13816 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 13817 
        else:
13818 
          iprot.skip(ftype)
8579 kshitij.so 13819 
      else:
13820 
        iprot.skip(ftype)
13821 
      iprot.readFieldEnd()
13822 
    iprot.readStructEnd()
13823 
 
13824 
  def write(self, oprot):
13825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13827 
      return
13828 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 13829 
    if self.bannerCongregate is not None:
13830 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
13831 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 13832 
      oprot.writeFieldEnd()
13833 
    oprot.writeFieldStop()
13834 
    oprot.writeStructEnd()
13835 
 
13836 
  def validate(self):
13837 
    return
13838 
 
13839 
 
13840 
  def __repr__(self):
13841 
    L = ['%s=%r' % (key, value)
13842 
      for key, value in self.__dict__.iteritems()]
13843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13844 
 
13845 
  def __eq__(self, other):
13846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13847 
 
13848 
  def __ne__(self, other):
13849 
    return not (self == other)
13850 
 
13851 
class addBanner_result:
10097 kshitij.so 13852 
  """
13853 
  Attributes:
13854 
   - success
13855 
  """
8579 kshitij.so 13856 
 
13857 
  thrift_spec = (
10097 kshitij.so 13858 
    (0, TType.BOOL, 'success', None, None, ), # 0
8579 kshitij.so 13859 
  )
13860 
 
10097 kshitij.so 13861 
  def __init__(self, success=None,):
13862 
    self.success = success
13863 
 
8579 kshitij.so 13864 
  def read(self, iprot):
13865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13867 
      return
13868 
    iprot.readStructBegin()
13869 
    while True:
13870 
      (fname, ftype, fid) = iprot.readFieldBegin()
13871 
      if ftype == TType.STOP:
13872 
        break
10097 kshitij.so 13873 
      if fid == 0:
13874 
        if ftype == TType.BOOL:
13875 
          self.success = iprot.readBool();
13876 
        else:
13877 
          iprot.skip(ftype)
8579 kshitij.so 13878 
      else:
13879 
        iprot.skip(ftype)
13880 
      iprot.readFieldEnd()
13881 
    iprot.readStructEnd()
13882 
 
13883 
  def write(self, oprot):
13884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13886 
      return
13887 
    oprot.writeStructBegin('addBanner_result')
10097 kshitij.so 13888 
    if self.success is not None:
13889 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13890 
      oprot.writeBool(self.success)
13891 
      oprot.writeFieldEnd()
8579 kshitij.so 13892 
    oprot.writeFieldStop()
13893 
    oprot.writeStructEnd()
13894 
 
13895 
  def validate(self):
13896 
    return
13897 
 
13898 
 
13899 
  def __repr__(self):
13900 
    L = ['%s=%r' % (key, value)
13901 
      for key, value in self.__dict__.iteritems()]
13902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13903 
 
13904 
  def __eq__(self, other):
13905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13906 
 
13907 
  def __ne__(self, other):
13908 
    return not (self == other)
13909 
 
13910 
class updateBanner_args:
13911 
  """
13912 
  Attributes:
13913 
   - banner
13914 
  """
13915 
 
13916 
  thrift_spec = (
13917 
    None, # 0
13918 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
13919 
  )
13920 
 
13921 
  def __init__(self, banner=None,):
13922 
    self.banner = banner
13923 
 
13924 
  def read(self, iprot):
13925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13927 
      return
13928 
    iprot.readStructBegin()
13929 
    while True:
13930 
      (fname, ftype, fid) = iprot.readFieldBegin()
13931 
      if ftype == TType.STOP:
13932 
        break
13933 
      if fid == 1:
13934 
        if ftype == TType.STRUCT:
13935 
          self.banner = Banner()
13936 
          self.banner.read(iprot)
6850 kshitij.so 13937 
        else:
13938 
          iprot.skip(ftype)
13939 
      else:
13940 
        iprot.skip(ftype)
13941 
      iprot.readFieldEnd()
13942 
    iprot.readStructEnd()
13943 
 
13944 
  def write(self, oprot):
13945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13947 
      return
8579 kshitij.so 13948 
    oprot.writeStructBegin('updateBanner_args')
13949 
    if self.banner is not None:
13950 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
13951 
      self.banner.write(oprot)
6850 kshitij.so 13952 
      oprot.writeFieldEnd()
13953 
    oprot.writeFieldStop()
13954 
    oprot.writeStructEnd()
13955 
 
13956 
  def validate(self):
13957 
    return
13958 
 
13959 
 
13960 
  def __repr__(self):
13961 
    L = ['%s=%r' % (key, value)
13962 
      for key, value in self.__dict__.iteritems()]
13963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13964 
 
13965 
  def __eq__(self, other):
13966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13967 
 
13968 
  def __ne__(self, other):
13969 
    return not (self == other)
13970 
 
8579 kshitij.so 13971 
class updateBanner_result:
6850 kshitij.so 13972 
  """
13973 
  Attributes:
13974 
   - success
13975 
  """
13976 
 
13977 
  thrift_spec = (
13978 
    (0, TType.BOOL, 'success', None, None, ), # 0
13979 
  )
13980 
 
13981 
  def __init__(self, success=None,):
13982 
    self.success = success
13983 
 
13984 
  def read(self, iprot):
13985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13987 
      return
13988 
    iprot.readStructBegin()
13989 
    while True:
13990 
      (fname, ftype, fid) = iprot.readFieldBegin()
13991 
      if ftype == TType.STOP:
13992 
        break
13993 
      if fid == 0:
13994 
        if ftype == TType.BOOL:
13995 
          self.success = iprot.readBool();
13996 
        else:
13997 
          iprot.skip(ftype)
13998 
      else:
13999 
        iprot.skip(ftype)
14000 
      iprot.readFieldEnd()
14001 
    iprot.readStructEnd()
14002 
 
14003 
  def write(self, oprot):
14004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14006 
      return
8579 kshitij.so 14007 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 14008 
    if self.success is not None:
14009 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14010 
      oprot.writeBool(self.success)
14011 
      oprot.writeFieldEnd()
14012 
    oprot.writeFieldStop()
14013 
    oprot.writeStructEnd()
14014 
 
14015 
  def validate(self):
14016 
    return
14017 
 
14018 
 
14019 
  def __repr__(self):
14020 
    L = ['%s=%r' % (key, value)
14021 
      for key, value in self.__dict__.iteritems()]
14022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14023 
 
14024 
  def __eq__(self, other):
14025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14026 
 
14027 
  def __ne__(self, other):
14028 
    return not (self == other)
14029 
 
14030 
class getAllBanners_args:
14031 
 
14032 
  thrift_spec = (
14033 
  )
14034 
 
14035 
  def read(self, iprot):
14036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14038 
      return
14039 
    iprot.readStructBegin()
14040 
    while True:
14041 
      (fname, ftype, fid) = iprot.readFieldBegin()
14042 
      if ftype == TType.STOP:
14043 
        break
14044 
      else:
14045 
        iprot.skip(ftype)
14046 
      iprot.readFieldEnd()
14047 
    iprot.readStructEnd()
14048 
 
14049 
  def write(self, oprot):
14050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14052 
      return
14053 
    oprot.writeStructBegin('getAllBanners_args')
14054 
    oprot.writeFieldStop()
14055 
    oprot.writeStructEnd()
14056 
 
14057 
  def validate(self):
14058 
    return
14059 
 
14060 
 
14061 
  def __repr__(self):
14062 
    L = ['%s=%r' % (key, value)
14063 
      for key, value in self.__dict__.iteritems()]
14064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14065 
 
14066 
  def __eq__(self, other):
14067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14068 
 
14069 
  def __ne__(self, other):
14070 
    return not (self == other)
14071 
 
14072 
class getAllBanners_result:
14073 
  """
14074 
  Attributes:
14075 
   - success
14076 
  """
14077 
 
14078 
  thrift_spec = (
8579 kshitij.so 14079 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 14080 
  )
14081 
 
14082 
  def __init__(self, success=None,):
14083 
    self.success = success
14084 
 
14085 
  def read(self, iprot):
14086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14088 
      return
14089 
    iprot.readStructBegin()
14090 
    while True:
14091 
      (fname, ftype, fid) = iprot.readFieldBegin()
14092 
      if ftype == TType.STOP:
14093 
        break
14094 
      if fid == 0:
14095 
        if ftype == TType.LIST:
14096 
          self.success = []
8590 kshitij.so 14097 
          (_etype198, _size195) = iprot.readListBegin()
14098 
          for _i199 in xrange(_size195):
14099 
            _elem200 = Banner()
14100 
            _elem200.read(iprot)
14101 
            self.success.append(_elem200)
6850 kshitij.so 14102 
          iprot.readListEnd()
14103 
        else:
14104 
          iprot.skip(ftype)
14105 
      else:
14106 
        iprot.skip(ftype)
14107 
      iprot.readFieldEnd()
14108 
    iprot.readStructEnd()
14109 
 
14110 
  def write(self, oprot):
14111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14113 
      return
14114 
    oprot.writeStructBegin('getAllBanners_result')
14115 
    if self.success is not None:
14116 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 14117 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14118 
      for iter201 in self.success:
14119 
        iter201.write(oprot)
6850 kshitij.so 14120 
      oprot.writeListEnd()
14121 
      oprot.writeFieldEnd()
14122 
    oprot.writeFieldStop()
14123 
    oprot.writeStructEnd()
14124 
 
14125 
  def validate(self):
14126 
    return
14127 
 
14128 
 
14129 
  def __repr__(self):
14130 
    L = ['%s=%r' % (key, value)
14131 
      for key, value in self.__dict__.iteritems()]
14132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14133 
 
14134 
  def __eq__(self, other):
14135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14136 
 
14137 
  def __ne__(self, other):
14138 
    return not (self == other)
14139 
 
14140 
class deleteBanner_args:
14141 
  """
14142 
  Attributes:
14143 
   - bannerName
9155 kshitij.so 14144 
   - bannerType
6850 kshitij.so 14145 
  """
14146 
 
14147 
  thrift_spec = (
14148 
    None, # 0
14149 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14150 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 14151 
  )
14152 
 
9155 kshitij.so 14153 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 14154 
    self.bannerName = bannerName
9155 kshitij.so 14155 
    self.bannerType = bannerType
6850 kshitij.so 14156 
 
14157 
  def read(self, iprot):
14158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14160 
      return
14161 
    iprot.readStructBegin()
14162 
    while True:
14163 
      (fname, ftype, fid) = iprot.readFieldBegin()
14164 
      if ftype == TType.STOP:
14165 
        break
14166 
      if fid == 1:
14167 
        if ftype == TType.STRING:
14168 
          self.bannerName = iprot.readString();
14169 
        else:
14170 
          iprot.skip(ftype)
9155 kshitij.so 14171 
      elif fid == 2:
14172 
        if ftype == TType.I32:
14173 
          self.bannerType = iprot.readI32();
14174 
        else:
14175 
          iprot.skip(ftype)
6850 kshitij.so 14176 
      else:
14177 
        iprot.skip(ftype)
14178 
      iprot.readFieldEnd()
14179 
    iprot.readStructEnd()
14180 
 
14181 
  def write(self, oprot):
14182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14184 
      return
14185 
    oprot.writeStructBegin('deleteBanner_args')
14186 
    if self.bannerName is not None:
14187 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14188 
      oprot.writeString(self.bannerName)
14189 
      oprot.writeFieldEnd()
9155 kshitij.so 14190 
    if self.bannerType is not None:
14191 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14192 
      oprot.writeI32(self.bannerType)
14193 
      oprot.writeFieldEnd()
6850 kshitij.so 14194 
    oprot.writeFieldStop()
14195 
    oprot.writeStructEnd()
14196 
 
14197 
  def validate(self):
14198 
    return
14199 
 
14200 
 
14201 
  def __repr__(self):
14202 
    L = ['%s=%r' % (key, value)
14203 
      for key, value in self.__dict__.iteritems()]
14204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14205 
 
14206 
  def __eq__(self, other):
14207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14208 
 
14209 
  def __ne__(self, other):
14210 
    return not (self == other)
14211 
 
14212 
class deleteBanner_result:
14213 
  """
14214 
  Attributes:
14215 
   - success
14216 
  """
14217 
 
14218 
  thrift_spec = (
14219 
    (0, TType.BOOL, 'success', None, None, ), # 0
14220 
  )
14221 
 
14222 
  def __init__(self, success=None,):
14223 
    self.success = success
14224 
 
14225 
  def read(self, iprot):
14226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14228 
      return
14229 
    iprot.readStructBegin()
14230 
    while True:
14231 
      (fname, ftype, fid) = iprot.readFieldBegin()
14232 
      if ftype == TType.STOP:
14233 
        break
14234 
      if fid == 0:
14235 
        if ftype == TType.BOOL:
14236 
          self.success = iprot.readBool();
14237 
        else:
14238 
          iprot.skip(ftype)
14239 
      else:
14240 
        iprot.skip(ftype)
14241 
      iprot.readFieldEnd()
14242 
    iprot.readStructEnd()
14243 
 
14244 
  def write(self, oprot):
14245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14247 
      return
14248 
    oprot.writeStructBegin('deleteBanner_result')
14249 
    if self.success is not None:
14250 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14251 
      oprot.writeBool(self.success)
14252 
      oprot.writeFieldEnd()
14253 
    oprot.writeFieldStop()
14254 
    oprot.writeStructEnd()
14255 
 
14256 
  def validate(self):
14257 
    return
14258 
 
14259 
 
14260 
  def __repr__(self):
14261 
    L = ['%s=%r' % (key, value)
14262 
      for key, value in self.__dict__.iteritems()]
14263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14264 
 
14265 
  def __eq__(self, other):
14266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14267 
 
14268 
  def __ne__(self, other):
14269 
    return not (self == other)
14270 
 
14271 
class getBannerDetails_args:
14272 
  """
14273 
  Attributes:
14274 
   - bannerName
9155 kshitij.so 14275 
   - bannerType
6850 kshitij.so 14276 
  """
14277 
 
14278 
  thrift_spec = (
14279 
    None, # 0
14280 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14281 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 14282 
  )
14283 
 
9155 kshitij.so 14284 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 14285 
    self.bannerName = bannerName
9155 kshitij.so 14286 
    self.bannerType = bannerType
6850 kshitij.so 14287 
 
14288 
  def read(self, iprot):
14289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14291 
      return
14292 
    iprot.readStructBegin()
14293 
    while True:
14294 
      (fname, ftype, fid) = iprot.readFieldBegin()
14295 
      if ftype == TType.STOP:
14296 
        break
14297 
      if fid == 1:
14298 
        if ftype == TType.STRING:
14299 
          self.bannerName = iprot.readString();
14300 
        else:
14301 
          iprot.skip(ftype)
9155 kshitij.so 14302 
      elif fid == 2:
14303 
        if ftype == TType.I32:
14304 
          self.bannerType = iprot.readI32();
14305 
        else:
14306 
          iprot.skip(ftype)
6850 kshitij.so 14307 
      else:
14308 
        iprot.skip(ftype)
14309 
      iprot.readFieldEnd()
14310 
    iprot.readStructEnd()
14311 
 
14312 
  def write(self, oprot):
14313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14315 
      return
14316 
    oprot.writeStructBegin('getBannerDetails_args')
14317 
    if self.bannerName is not None:
14318 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14319 
      oprot.writeString(self.bannerName)
14320 
      oprot.writeFieldEnd()
9155 kshitij.so 14321 
    if self.bannerType is not None:
14322 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14323 
      oprot.writeI32(self.bannerType)
14324 
      oprot.writeFieldEnd()
6850 kshitij.so 14325 
    oprot.writeFieldStop()
14326 
    oprot.writeStructEnd()
14327 
 
14328 
  def validate(self):
14329 
    return
14330 
 
14331 
 
14332 
  def __repr__(self):
14333 
    L = ['%s=%r' % (key, value)
14334 
      for key, value in self.__dict__.iteritems()]
14335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14336 
 
14337 
  def __eq__(self, other):
14338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14339 
 
14340 
  def __ne__(self, other):
14341 
    return not (self == other)
14342 
 
14343 
class getBannerDetails_result:
14344 
  """
14345 
  Attributes:
14346 
   - success
14347 
  """
14348 
 
14349 
  thrift_spec = (
14350 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
14351 
  )
14352 
 
14353 
  def __init__(self, success=None,):
14354 
    self.success = success
14355 
 
14356 
  def read(self, iprot):
14357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14359 
      return
14360 
    iprot.readStructBegin()
14361 
    while True:
14362 
      (fname, ftype, fid) = iprot.readFieldBegin()
14363 
      if ftype == TType.STOP:
14364 
        break
14365 
      if fid == 0:
14366 
        if ftype == TType.STRUCT:
14367 
          self.success = Banner()
14368 
          self.success.read(iprot)
14369 
        else:
14370 
          iprot.skip(ftype)
14371 
      else:
14372 
        iprot.skip(ftype)
14373 
      iprot.readFieldEnd()
14374 
    iprot.readStructEnd()
14375 
 
14376 
  def write(self, oprot):
14377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14379 
      return
14380 
    oprot.writeStructBegin('getBannerDetails_result')
14381 
    if self.success is not None:
14382 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14383 
      self.success.write(oprot)
14384 
      oprot.writeFieldEnd()
14385 
    oprot.writeFieldStop()
14386 
    oprot.writeStructEnd()
14387 
 
14388 
  def validate(self):
14389 
    return
14390 
 
14391 
 
14392 
  def __repr__(self):
14393 
    L = ['%s=%r' % (key, value)
14394 
      for key, value in self.__dict__.iteritems()]
14395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14396 
 
14397 
  def __eq__(self, other):
14398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14399 
 
14400 
  def __ne__(self, other):
14401 
    return not (self == other)
14402 
 
14403 
class getActiveBanners_args:
14404 
 
14405 
  thrift_spec = (
14406 
  )
14407 
 
14408 
  def read(self, iprot):
14409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14411 
      return
14412 
    iprot.readStructBegin()
14413 
    while True:
14414 
      (fname, ftype, fid) = iprot.readFieldBegin()
14415 
      if ftype == TType.STOP:
14416 
        break
14417 
      else:
14418 
        iprot.skip(ftype)
14419 
      iprot.readFieldEnd()
14420 
    iprot.readStructEnd()
14421 
 
14422 
  def write(self, oprot):
14423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14425 
      return
14426 
    oprot.writeStructBegin('getActiveBanners_args')
14427 
    oprot.writeFieldStop()
14428 
    oprot.writeStructEnd()
14429 
 
14430 
  def validate(self):
14431 
    return
14432 
 
14433 
 
14434 
  def __repr__(self):
14435 
    L = ['%s=%r' % (key, value)
14436 
      for key, value in self.__dict__.iteritems()]
14437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14438 
 
14439 
  def __eq__(self, other):
14440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14441 
 
14442 
  def __ne__(self, other):
14443 
    return not (self == other)
14444 
 
14445 
class getActiveBanners_result:
14446 
  """
14447 
  Attributes:
14448 
   - success
14449 
  """
14450 
 
14451 
  thrift_spec = (
8579 kshitij.so 14452 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 14453 
  )
14454 
 
14455 
  def __init__(self, success=None,):
14456 
    self.success = success
14457 
 
14458 
  def read(self, iprot):
14459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14461 
      return
14462 
    iprot.readStructBegin()
14463 
    while True:
14464 
      (fname, ftype, fid) = iprot.readFieldBegin()
14465 
      if ftype == TType.STOP:
14466 
        break
14467 
      if fid == 0:
8579 kshitij.so 14468 
        if ftype == TType.MAP:
14469 
          self.success = {}
8590 kshitij.so 14470 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
14471 
          for _i206 in xrange(_size202):
14472 
            _key207 = iprot.readString();
14473 
            _val208 = []
14474 
            (_etype212, _size209) = iprot.readListBegin()
14475 
            for _i213 in xrange(_size209):
14476 
              _elem214 = Banner()
14477 
              _elem214.read(iprot)
14478 
              _val208.append(_elem214)
8579 kshitij.so 14479 
            iprot.readListEnd()
8590 kshitij.so 14480 
            self.success[_key207] = _val208
8579 kshitij.so 14481 
          iprot.readMapEnd()
6850 kshitij.so 14482 
        else:
14483 
          iprot.skip(ftype)
14484 
      else:
14485 
        iprot.skip(ftype)
14486 
      iprot.readFieldEnd()
14487 
    iprot.readStructEnd()
14488 
 
14489 
  def write(self, oprot):
14490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14492 
      return
14493 
    oprot.writeStructBegin('getActiveBanners_result')
14494 
    if self.success is not None:
8579 kshitij.so 14495 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14496 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 14497 
      for kiter215,viter216 in self.success.items():
14498 
        oprot.writeString(kiter215)
14499 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
14500 
        for iter217 in viter216:
14501 
          iter217.write(oprot)
8579 kshitij.so 14502 
        oprot.writeListEnd()
14503 
      oprot.writeMapEnd()
6850 kshitij.so 14504 
      oprot.writeFieldEnd()
14505 
    oprot.writeFieldStop()
14506 
    oprot.writeStructEnd()
14507 
 
14508 
  def validate(self):
14509 
    return
14510 
 
14511 
 
14512 
  def __repr__(self):
14513 
    L = ['%s=%r' % (key, value)
14514 
      for key, value in self.__dict__.iteritems()]
14515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14516 
 
14517 
  def __eq__(self, other):
14518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14519 
 
14520 
  def __ne__(self, other):
14521 
    return not (self == other)
14522 
 
6849 kshitij.so 14523 
class addBannerMap_args:
14524 
  """
14525 
  Attributes:
8579 kshitij.so 14526 
   - bannerMaps
6849 kshitij.so 14527 
  """
14528 
 
14529 
  thrift_spec = (
14530 
    None, # 0
8579 kshitij.so 14531 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 14532 
  )
14533 
 
8579 kshitij.so 14534 
  def __init__(self, bannerMaps=None,):
14535 
    self.bannerMaps = bannerMaps
6849 kshitij.so 14536 
 
14537 
  def read(self, iprot):
14538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14540 
      return
14541 
    iprot.readStructBegin()
14542 
    while True:
14543 
      (fname, ftype, fid) = iprot.readFieldBegin()
14544 
      if ftype == TType.STOP:
14545 
        break
14546 
      if fid == 1:
8579 kshitij.so 14547 
        if ftype == TType.LIST:
14548 
          self.bannerMaps = []
8590 kshitij.so 14549 
          (_etype221, _size218) = iprot.readListBegin()
14550 
          for _i222 in xrange(_size218):
14551 
            _elem223 = BannerMap()
14552 
            _elem223.read(iprot)
14553 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 14554 
          iprot.readListEnd()
6849 kshitij.so 14555 
        else:
14556 
          iprot.skip(ftype)
8579 kshitij.so 14557 
      else:
14558 
        iprot.skip(ftype)
14559 
      iprot.readFieldEnd()
14560 
    iprot.readStructEnd()
14561 
 
14562 
  def write(self, oprot):
14563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14565 
      return
14566 
    oprot.writeStructBegin('addBannerMap_args')
14567 
    if self.bannerMaps is not None:
14568 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
14569 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 14570 
      for iter224 in self.bannerMaps:
14571 
        iter224.write(oprot)
8579 kshitij.so 14572 
      oprot.writeListEnd()
14573 
      oprot.writeFieldEnd()
14574 
    oprot.writeFieldStop()
14575 
    oprot.writeStructEnd()
14576 
 
14577 
  def validate(self):
14578 
    return
14579 
 
14580 
 
14581 
  def __repr__(self):
14582 
    L = ['%s=%r' % (key, value)
14583 
      for key, value in self.__dict__.iteritems()]
14584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14585 
 
14586 
  def __eq__(self, other):
14587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14588 
 
14589 
  def __ne__(self, other):
14590 
    return not (self == other)
14591 
 
14592 
class addBannerMap_result:
14593 
  """
14594 
  Attributes:
14595 
   - success
14596 
  """
14597 
 
14598 
  thrift_spec = (
14599 
    (0, TType.BOOL, 'success', None, None, ), # 0
14600 
  )
14601 
 
14602 
  def __init__(self, success=None,):
14603 
    self.success = success
14604 
 
14605 
  def read(self, iprot):
14606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14608 
      return
14609 
    iprot.readStructBegin()
14610 
    while True:
14611 
      (fname, ftype, fid) = iprot.readFieldBegin()
14612 
      if ftype == TType.STOP:
14613 
        break
14614 
      if fid == 0:
14615 
        if ftype == TType.BOOL:
14616 
          self.success = iprot.readBool();
6849 kshitij.so 14617 
        else:
14618 
          iprot.skip(ftype)
8579 kshitij.so 14619 
      else:
14620 
        iprot.skip(ftype)
14621 
      iprot.readFieldEnd()
14622 
    iprot.readStructEnd()
14623 
 
14624 
  def write(self, oprot):
14625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14627 
      return
14628 
    oprot.writeStructBegin('addBannerMap_result')
14629 
    if self.success is not None:
14630 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14631 
      oprot.writeBool(self.success)
14632 
      oprot.writeFieldEnd()
14633 
    oprot.writeFieldStop()
14634 
    oprot.writeStructEnd()
14635 
 
14636 
  def validate(self):
14637 
    return
14638 
 
14639 
 
14640 
  def __repr__(self):
14641 
    L = ['%s=%r' % (key, value)
14642 
      for key, value in self.__dict__.iteritems()]
14643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14644 
 
14645 
  def __eq__(self, other):
14646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14647 
 
14648 
  def __ne__(self, other):
14649 
    return not (self == other)
14650 
 
14651 
class updateBannerMap_args:
14652 
  """
14653 
  Attributes:
14654 
   - bannerMap
14655 
  """
14656 
 
14657 
  thrift_spec = (
14658 
    None, # 0
14659 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
14660 
  )
14661 
 
14662 
  def __init__(self, bannerMap=None,):
14663 
    self.bannerMap = bannerMap
14664 
 
14665 
  def read(self, iprot):
14666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14668 
      return
14669 
    iprot.readStructBegin()
14670 
    while True:
14671 
      (fname, ftype, fid) = iprot.readFieldBegin()
14672 
      if ftype == TType.STOP:
14673 
        break
14674 
      if fid == 1:
14675 
        if ftype == TType.STRUCT:
14676 
          self.bannerMap = BannerMap()
14677 
          self.bannerMap.read(iprot)
6849 kshitij.so 14678 
        else:
14679 
          iprot.skip(ftype)
14680 
      else:
14681 
        iprot.skip(ftype)
14682 
      iprot.readFieldEnd()
14683 
    iprot.readStructEnd()
14684 
 
14685 
  def write(self, oprot):
14686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14688 
      return
8579 kshitij.so 14689 
    oprot.writeStructBegin('updateBannerMap_args')
14690 
    if self.bannerMap is not None:
14691 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
14692 
      self.bannerMap.write(oprot)
6849 kshitij.so 14693 
      oprot.writeFieldEnd()
14694 
    oprot.writeFieldStop()
14695 
    oprot.writeStructEnd()
14696 
 
14697 
  def validate(self):
14698 
    return
14699 
 
14700 
 
14701 
  def __repr__(self):
14702 
    L = ['%s=%r' % (key, value)
14703 
      for key, value in self.__dict__.iteritems()]
14704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14705 
 
14706 
  def __eq__(self, other):
14707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14708 
 
14709 
  def __ne__(self, other):
14710 
    return not (self == other)
14711 
 
8579 kshitij.so 14712 
class updateBannerMap_result:
6849 kshitij.so 14713 
  """
14714 
  Attributes:
14715 
   - success
14716 
  """
14717 
 
14718 
  thrift_spec = (
14719 
    (0, TType.BOOL, 'success', None, None, ), # 0
14720 
  )
14721 
 
14722 
  def __init__(self, success=None,):
14723 
    self.success = success
14724 
 
14725 
  def read(self, iprot):
14726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14728 
      return
14729 
    iprot.readStructBegin()
14730 
    while True:
14731 
      (fname, ftype, fid) = iprot.readFieldBegin()
14732 
      if ftype == TType.STOP:
14733 
        break
14734 
      if fid == 0:
14735 
        if ftype == TType.BOOL:
14736 
          self.success = iprot.readBool();
14737 
        else:
14738 
          iprot.skip(ftype)
14739 
      else:
14740 
        iprot.skip(ftype)
14741 
      iprot.readFieldEnd()
14742 
    iprot.readStructEnd()
14743 
 
14744 
  def write(self, oprot):
14745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14747 
      return
8579 kshitij.so 14748 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 14749 
    if self.success is not None:
14750 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14751 
      oprot.writeBool(self.success)
14752 
      oprot.writeFieldEnd()
14753 
    oprot.writeFieldStop()
14754 
    oprot.writeStructEnd()
14755 
 
14756 
  def validate(self):
14757 
    return
14758 
 
14759 
 
14760 
  def __repr__(self):
14761 
    L = ['%s=%r' % (key, value)
14762 
      for key, value in self.__dict__.iteritems()]
14763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14764 
 
14765 
  def __eq__(self, other):
14766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14767 
 
14768 
  def __ne__(self, other):
14769 
    return not (self == other)
14770 
 
14771 
class deleteBannerMap_args:
14772 
  """
14773 
  Attributes:
14774 
   - bannerName
14775 
  """
14776 
 
14777 
  thrift_spec = (
14778 
    None, # 0
14779 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
14780 
  )
14781 
 
14782 
  def __init__(self, bannerName=None,):
14783 
    self.bannerName = bannerName
14784 
 
14785 
  def read(self, iprot):
14786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14788 
      return
14789 
    iprot.readStructBegin()
14790 
    while True:
14791 
      (fname, ftype, fid) = iprot.readFieldBegin()
14792 
      if ftype == TType.STOP:
14793 
        break
14794 
      if fid == 1:
14795 
        if ftype == TType.STRING:
14796 
          self.bannerName = iprot.readString();
14797 
        else:
14798 
          iprot.skip(ftype)
14799 
      else:
14800 
        iprot.skip(ftype)
14801 
      iprot.readFieldEnd()
14802 
    iprot.readStructEnd()
14803 
 
14804 
  def write(self, oprot):
14805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14807 
      return
14808 
    oprot.writeStructBegin('deleteBannerMap_args')
14809 
    if self.bannerName is not None:
14810 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14811 
      oprot.writeString(self.bannerName)
14812 
      oprot.writeFieldEnd()
14813 
    oprot.writeFieldStop()
14814 
    oprot.writeStructEnd()
14815 
 
14816 
  def validate(self):
14817 
    return
14818 
 
14819 
 
14820 
  def __repr__(self):
14821 
    L = ['%s=%r' % (key, value)
14822 
      for key, value in self.__dict__.iteritems()]
14823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14824 
 
14825 
  def __eq__(self, other):
14826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14827 
 
14828 
  def __ne__(self, other):
14829 
    return not (self == other)
14830 
 
14831 
class deleteBannerMap_result:
14832 
  """
14833 
  Attributes:
14834 
   - success
14835 
  """
14836 
 
14837 
  thrift_spec = (
14838 
    (0, TType.BOOL, 'success', None, None, ), # 0
14839 
  )
14840 
 
14841 
  def __init__(self, success=None,):
14842 
    self.success = success
14843 
 
14844 
  def read(self, iprot):
14845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14847 
      return
14848 
    iprot.readStructBegin()
14849 
    while True:
14850 
      (fname, ftype, fid) = iprot.readFieldBegin()
14851 
      if ftype == TType.STOP:
14852 
        break
14853 
      if fid == 0:
14854 
        if ftype == TType.BOOL:
14855 
          self.success = iprot.readBool();
14856 
        else:
14857 
          iprot.skip(ftype)
14858 
      else:
14859 
        iprot.skip(ftype)
14860 
      iprot.readFieldEnd()
14861 
    iprot.readStructEnd()
14862 
 
14863 
  def write(self, oprot):
14864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14866 
      return
14867 
    oprot.writeStructBegin('deleteBannerMap_result')
14868 
    if self.success is not None:
14869 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14870 
      oprot.writeBool(self.success)
14871 
      oprot.writeFieldEnd()
14872 
    oprot.writeFieldStop()
14873 
    oprot.writeStructEnd()
14874 
 
14875 
  def validate(self):
14876 
    return
14877 
 
14878 
 
14879 
  def __repr__(self):
14880 
    L = ['%s=%r' % (key, value)
14881 
      for key, value in self.__dict__.iteritems()]
14882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14883 
 
14884 
  def __eq__(self, other):
14885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14886 
 
14887 
  def __ne__(self, other):
14888 
    return not (self == other)
14889 
 
14890 
class getBannerMapDetails_args:
14891 
  """
14892 
  Attributes:
14893 
   - bannerName
9155 kshitij.so 14894 
   - bannerType
6849 kshitij.so 14895 
  """
14896 
 
14897 
  thrift_spec = (
14898 
    None, # 0
14899 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14900 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 14901 
  )
14902 
 
9155 kshitij.so 14903 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 14904 
    self.bannerName = bannerName
9155 kshitij.so 14905 
    self.bannerType = bannerType
6849 kshitij.so 14906 
 
14907 
  def read(self, iprot):
14908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14910 
      return
14911 
    iprot.readStructBegin()
14912 
    while True:
14913 
      (fname, ftype, fid) = iprot.readFieldBegin()
14914 
      if ftype == TType.STOP:
14915 
        break
14916 
      if fid == 1:
14917 
        if ftype == TType.STRING:
14918 
          self.bannerName = iprot.readString();
14919 
        else:
14920 
          iprot.skip(ftype)
9155 kshitij.so 14921 
      elif fid == 2:
14922 
        if ftype == TType.I32:
14923 
          self.bannerType = iprot.readI32();
14924 
        else:
14925 
          iprot.skip(ftype)
6849 kshitij.so 14926 
      else:
14927 
        iprot.skip(ftype)
14928 
      iprot.readFieldEnd()
14929 
    iprot.readStructEnd()
14930 
 
14931 
  def write(self, oprot):
14932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14934 
      return
14935 
    oprot.writeStructBegin('getBannerMapDetails_args')
14936 
    if self.bannerName is not None:
14937 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14938 
      oprot.writeString(self.bannerName)
14939 
      oprot.writeFieldEnd()
9155 kshitij.so 14940 
    if self.bannerType is not None:
14941 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14942 
      oprot.writeI32(self.bannerType)
14943 
      oprot.writeFieldEnd()
6849 kshitij.so 14944 
    oprot.writeFieldStop()
14945 
    oprot.writeStructEnd()
14946 
 
14947 
  def validate(self):
14948 
    return
14949 
 
14950 
 
14951 
  def __repr__(self):
14952 
    L = ['%s=%r' % (key, value)
14953 
      for key, value in self.__dict__.iteritems()]
14954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14955 
 
14956 
  def __eq__(self, other):
14957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14958 
 
14959 
  def __ne__(self, other):
14960 
    return not (self == other)
14961 
 
14962 
class getBannerMapDetails_result:
14963 
  """
14964 
  Attributes:
14965 
   - success
14966 
  """
14967 
 
14968 
  thrift_spec = (
14969 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
14970 
  )
14971 
 
14972 
  def __init__(self, success=None,):
14973 
    self.success = success
14974 
 
14975 
  def read(self, iprot):
14976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14978 
      return
14979 
    iprot.readStructBegin()
14980 
    while True:
14981 
      (fname, ftype, fid) = iprot.readFieldBegin()
14982 
      if ftype == TType.STOP:
14983 
        break
14984 
      if fid == 0:
14985 
        if ftype == TType.LIST:
14986 
          self.success = []
8590 kshitij.so 14987 
          (_etype228, _size225) = iprot.readListBegin()
14988 
          for _i229 in xrange(_size225):
14989 
            _elem230 = BannerMap()
14990 
            _elem230.read(iprot)
14991 
            self.success.append(_elem230)
6849 kshitij.so 14992 
          iprot.readListEnd()
14993 
        else:
14994 
          iprot.skip(ftype)
14995 
      else:
14996 
        iprot.skip(ftype)
14997 
      iprot.readFieldEnd()
14998 
    iprot.readStructEnd()
14999 
 
15000 
  def write(self, oprot):
15001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15003 
      return
15004 
    oprot.writeStructBegin('getBannerMapDetails_result')
15005 
    if self.success is not None:
15006 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15007 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15008 
      for iter231 in self.success:
15009 
        iter231.write(oprot)
6849 kshitij.so 15010 
      oprot.writeListEnd()
15011 
      oprot.writeFieldEnd()
15012 
    oprot.writeFieldStop()
15013 
    oprot.writeStructEnd()
15014 
 
15015 
  def validate(self):
15016 
    return
15017 
 
15018 
 
15019 
  def __repr__(self):
15020 
    L = ['%s=%r' % (key, value)
15021 
      for key, value in self.__dict__.iteritems()]
15022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15023 
 
15024 
  def __eq__(self, other):
15025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15026 
 
15027 
  def __ne__(self, other):
15028 
    return not (self == other)
15029 
 
8579 kshitij.so 15030 
class addBannerUri_args:
15031 
  """
15032 
  Attributes:
15033 
   - bannerUriMappings
15034 
  """
15035 
 
15036 
  thrift_spec = (
15037 
    None, # 0
15038 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
15039 
  )
15040 
 
15041 
  def __init__(self, bannerUriMappings=None,):
15042 
    self.bannerUriMappings = bannerUriMappings
15043 
 
15044 
  def read(self, iprot):
15045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15047 
      return
15048 
    iprot.readStructBegin()
15049 
    while True:
15050 
      (fname, ftype, fid) = iprot.readFieldBegin()
15051 
      if ftype == TType.STOP:
15052 
        break
15053 
      if fid == 1:
15054 
        if ftype == TType.LIST:
15055 
          self.bannerUriMappings = []
8590 kshitij.so 15056 
          (_etype235, _size232) = iprot.readListBegin()
15057 
          for _i236 in xrange(_size232):
15058 
            _elem237 = BannerUriMapping()
15059 
            _elem237.read(iprot)
15060 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 15061 
          iprot.readListEnd()
15062 
        else:
15063 
          iprot.skip(ftype)
15064 
      else:
15065 
        iprot.skip(ftype)
15066 
      iprot.readFieldEnd()
15067 
    iprot.readStructEnd()
15068 
 
15069 
  def write(self, oprot):
15070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15072 
      return
15073 
    oprot.writeStructBegin('addBannerUri_args')
15074 
    if self.bannerUriMappings is not None:
15075 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
15076 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 15077 
      for iter238 in self.bannerUriMappings:
15078 
        iter238.write(oprot)
8579 kshitij.so 15079 
      oprot.writeListEnd()
15080 
      oprot.writeFieldEnd()
15081 
    oprot.writeFieldStop()
15082 
    oprot.writeStructEnd()
15083 
 
15084 
  def validate(self):
15085 
    return
15086 
 
15087 
 
15088 
  def __repr__(self):
15089 
    L = ['%s=%r' % (key, value)
15090 
      for key, value in self.__dict__.iteritems()]
15091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15092 
 
15093 
  def __eq__(self, other):
15094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15095 
 
15096 
  def __ne__(self, other):
15097 
    return not (self == other)
15098 
 
15099 
class addBannerUri_result:
15100 
 
15101 
  thrift_spec = (
15102 
  )
15103 
 
15104 
  def read(self, iprot):
15105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15107 
      return
15108 
    iprot.readStructBegin()
15109 
    while True:
15110 
      (fname, ftype, fid) = iprot.readFieldBegin()
15111 
      if ftype == TType.STOP:
15112 
        break
15113 
      else:
15114 
        iprot.skip(ftype)
15115 
      iprot.readFieldEnd()
15116 
    iprot.readStructEnd()
15117 
 
15118 
  def write(self, oprot):
15119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15121 
      return
15122 
    oprot.writeStructBegin('addBannerUri_result')
15123 
    oprot.writeFieldStop()
15124 
    oprot.writeStructEnd()
15125 
 
15126 
  def validate(self):
15127 
    return
15128 
 
15129 
 
15130 
  def __repr__(self):
15131 
    L = ['%s=%r' % (key, value)
15132 
      for key, value in self.__dict__.iteritems()]
15133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15134 
 
15135 
  def __eq__(self, other):
15136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15137 
 
15138 
  def __ne__(self, other):
15139 
    return not (self == other)
15140 
 
15141 
class getUriMapping_args:
15142 
  """
15143 
  Attributes:
15144 
   - bannerName
9155 kshitij.so 15145 
   - bannerType
8579 kshitij.so 15146 
  """
15147 
 
15148 
  thrift_spec = (
15149 
    None, # 0
15150 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 15151 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 15152 
  )
15153 
 
9155 kshitij.so 15154 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 15155 
    self.bannerName = bannerName
9155 kshitij.so 15156 
    self.bannerType = bannerType
8579 kshitij.so 15157 
 
15158 
  def read(self, iprot):
15159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15161 
      return
15162 
    iprot.readStructBegin()
15163 
    while True:
15164 
      (fname, ftype, fid) = iprot.readFieldBegin()
15165 
      if ftype == TType.STOP:
15166 
        break
15167 
      if fid == 1:
15168 
        if ftype == TType.STRING:
15169 
          self.bannerName = iprot.readString();
15170 
        else:
15171 
          iprot.skip(ftype)
9155 kshitij.so 15172 
      elif fid == 2:
15173 
        if ftype == TType.I32:
15174 
          self.bannerType = iprot.readI32();
15175 
        else:
15176 
          iprot.skip(ftype)
8579 kshitij.so 15177 
      else:
15178 
        iprot.skip(ftype)
15179 
      iprot.readFieldEnd()
15180 
    iprot.readStructEnd()
15181 
 
15182 
  def write(self, oprot):
15183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15185 
      return
15186 
    oprot.writeStructBegin('getUriMapping_args')
15187 
    if self.bannerName is not None:
15188 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
15189 
      oprot.writeString(self.bannerName)
15190 
      oprot.writeFieldEnd()
9155 kshitij.so 15191 
    if self.bannerType is not None:
15192 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
15193 
      oprot.writeI32(self.bannerType)
15194 
      oprot.writeFieldEnd()
8579 kshitij.so 15195 
    oprot.writeFieldStop()
15196 
    oprot.writeStructEnd()
15197 
 
15198 
  def validate(self):
15199 
    return
15200 
 
15201 
 
15202 
  def __repr__(self):
15203 
    L = ['%s=%r' % (key, value)
15204 
      for key, value in self.__dict__.iteritems()]
15205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15206 
 
15207 
  def __eq__(self, other):
15208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15209 
 
15210 
  def __ne__(self, other):
15211 
    return not (self == other)
15212 
 
15213 
class getUriMapping_result:
15214 
  """
15215 
  Attributes:
15216 
   - success
15217 
  """
15218 
 
15219 
  thrift_spec = (
15220 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
15221 
  )
15222 
 
15223 
  def __init__(self, success=None,):
15224 
    self.success = success
15225 
 
15226 
  def read(self, iprot):
15227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15229 
      return
15230 
    iprot.readStructBegin()
15231 
    while True:
15232 
      (fname, ftype, fid) = iprot.readFieldBegin()
15233 
      if ftype == TType.STOP:
15234 
        break
15235 
      if fid == 0:
15236 
        if ftype == TType.LIST:
15237 
          self.success = []
8590 kshitij.so 15238 
          (_etype242, _size239) = iprot.readListBegin()
15239 
          for _i243 in xrange(_size239):
15240 
            _elem244 = BannerUriMapping()
15241 
            _elem244.read(iprot)
15242 
            self.success.append(_elem244)
8579 kshitij.so 15243 
          iprot.readListEnd()
15244 
        else:
15245 
          iprot.skip(ftype)
15246 
      else:
15247 
        iprot.skip(ftype)
15248 
      iprot.readFieldEnd()
15249 
    iprot.readStructEnd()
15250 
 
15251 
  def write(self, oprot):
15252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15254 
      return
15255 
    oprot.writeStructBegin('getUriMapping_result')
15256 
    if self.success is not None:
15257 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15258 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15259 
      for iter245 in self.success:
15260 
        iter245.write(oprot)
8579 kshitij.so 15261 
      oprot.writeListEnd()
15262 
      oprot.writeFieldEnd()
15263 
    oprot.writeFieldStop()
15264 
    oprot.writeStructEnd()
15265 
 
15266 
  def validate(self):
15267 
    return
15268 
 
15269 
 
15270 
  def __repr__(self):
15271 
    L = ['%s=%r' % (key, value)
15272 
      for key, value in self.__dict__.iteritems()]
15273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15274 
 
15275 
  def __eq__(self, other):
15276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15277 
 
15278 
  def __ne__(self, other):
15279 
    return not (self == other)
15280 
 
15281 
class addCampaign_args:
15282 
  """
15283 
  Attributes:
15284 
   - campaign
15285 
  """
15286 
 
15287 
  thrift_spec = (
15288 
    None, # 0
15289 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
15290 
  )
15291 
 
15292 
  def __init__(self, campaign=None,):
15293 
    self.campaign = campaign
15294 
 
15295 
  def read(self, iprot):
15296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15298 
      return
15299 
    iprot.readStructBegin()
15300 
    while True:
15301 
      (fname, ftype, fid) = iprot.readFieldBegin()
15302 
      if ftype == TType.STOP:
15303 
        break
15304 
      if fid == 1:
15305 
        if ftype == TType.STRUCT:
15306 
          self.campaign = Campaign()
15307 
          self.campaign.read(iprot)
15308 
        else:
15309 
          iprot.skip(ftype)
15310 
      else:
15311 
        iprot.skip(ftype)
15312 
      iprot.readFieldEnd()
15313 
    iprot.readStructEnd()
15314 
 
15315 
  def write(self, oprot):
15316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15318 
      return
15319 
    oprot.writeStructBegin('addCampaign_args')
15320 
    if self.campaign is not None:
15321 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
15322 
      self.campaign.write(oprot)
15323 
      oprot.writeFieldEnd()
15324 
    oprot.writeFieldStop()
15325 
    oprot.writeStructEnd()
15326 
 
15327 
  def validate(self):
15328 
    return
15329 
 
15330 
 
15331 
  def __repr__(self):
15332 
    L = ['%s=%r' % (key, value)
15333 
      for key, value in self.__dict__.iteritems()]
15334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15335 
 
15336 
  def __eq__(self, other):
15337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15338 
 
15339 
  def __ne__(self, other):
15340 
    return not (self == other)
15341 
 
15342 
class addCampaign_result:
15343 
 
15344 
  thrift_spec = (
15345 
  )
15346 
 
15347 
  def read(self, iprot):
15348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15350 
      return
15351 
    iprot.readStructBegin()
15352 
    while True:
15353 
      (fname, ftype, fid) = iprot.readFieldBegin()
15354 
      if ftype == TType.STOP:
15355 
        break
15356 
      else:
15357 
        iprot.skip(ftype)
15358 
      iprot.readFieldEnd()
15359 
    iprot.readStructEnd()
15360 
 
15361 
  def write(self, oprot):
15362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15364 
      return
15365 
    oprot.writeStructBegin('addCampaign_result')
15366 
    oprot.writeFieldStop()
15367 
    oprot.writeStructEnd()
15368 
 
15369 
  def validate(self):
15370 
    return
15371 
 
15372 
 
15373 
  def __repr__(self):
15374 
    L = ['%s=%r' % (key, value)
15375 
      for key, value in self.__dict__.iteritems()]
15376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15377 
 
15378 
  def __eq__(self, other):
15379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15380 
 
15381 
  def __ne__(self, other):
15382 
    return not (self == other)
15383 
 
15384 
class getCampaigns_args:
15385 
  """
15386 
  Attributes:
15387 
   - campaignName
15388 
  """
15389 
 
15390 
  thrift_spec = (
15391 
    None, # 0
15392 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
15393 
  )
15394 
 
15395 
  def __init__(self, campaignName=None,):
15396 
    self.campaignName = campaignName
15397 
 
15398 
  def read(self, iprot):
15399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15401 
      return
15402 
    iprot.readStructBegin()
15403 
    while True:
15404 
      (fname, ftype, fid) = iprot.readFieldBegin()
15405 
      if ftype == TType.STOP:
15406 
        break
15407 
      if fid == 1:
15408 
        if ftype == TType.STRING:
15409 
          self.campaignName = iprot.readString();
15410 
        else:
15411 
          iprot.skip(ftype)
15412 
      else:
15413 
        iprot.skip(ftype)
15414 
      iprot.readFieldEnd()
15415 
    iprot.readStructEnd()
15416 
 
15417 
  def write(self, oprot):
15418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15420 
      return
15421 
    oprot.writeStructBegin('getCampaigns_args')
15422 
    if self.campaignName is not None:
15423 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
15424 
      oprot.writeString(self.campaignName)
15425 
      oprot.writeFieldEnd()
15426 
    oprot.writeFieldStop()
15427 
    oprot.writeStructEnd()
15428 
 
15429 
  def validate(self):
15430 
    return
15431 
 
15432 
 
15433 
  def __repr__(self):
15434 
    L = ['%s=%r' % (key, value)
15435 
      for key, value in self.__dict__.iteritems()]
15436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15437 
 
15438 
  def __eq__(self, other):
15439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15440 
 
15441 
  def __ne__(self, other):
15442 
    return not (self == other)
15443 
 
15444 
class getCampaigns_result:
15445 
  """
15446 
  Attributes:
15447 
   - success
15448 
  """
15449 
 
15450 
  thrift_spec = (
15451 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
15452 
  )
15453 
 
15454 
  def __init__(self, success=None,):
15455 
    self.success = success
15456 
 
15457 
  def read(self, iprot):
15458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15460 
      return
15461 
    iprot.readStructBegin()
15462 
    while True:
15463 
      (fname, ftype, fid) = iprot.readFieldBegin()
15464 
      if ftype == TType.STOP:
15465 
        break
15466 
      if fid == 0:
15467 
        if ftype == TType.LIST:
15468 
          self.success = []
8590 kshitij.so 15469 
          (_etype249, _size246) = iprot.readListBegin()
15470 
          for _i250 in xrange(_size246):
15471 
            _elem251 = Campaign()
15472 
            _elem251.read(iprot)
15473 
            self.success.append(_elem251)
8579 kshitij.so 15474 
          iprot.readListEnd()
15475 
        else:
15476 
          iprot.skip(ftype)
15477 
      else:
15478 
        iprot.skip(ftype)
15479 
      iprot.readFieldEnd()
15480 
    iprot.readStructEnd()
15481 
 
15482 
  def write(self, oprot):
15483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15485 
      return
15486 
    oprot.writeStructBegin('getCampaigns_result')
15487 
    if self.success is not None:
15488 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15489 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15490 
      for iter252 in self.success:
15491 
        iter252.write(oprot)
8579 kshitij.so 15492 
      oprot.writeListEnd()
15493 
      oprot.writeFieldEnd()
15494 
    oprot.writeFieldStop()
15495 
    oprot.writeStructEnd()
15496 
 
15497 
  def validate(self):
15498 
    return
15499 
 
15500 
 
15501 
  def __repr__(self):
15502 
    L = ['%s=%r' % (key, value)
15503 
      for key, value in self.__dict__.iteritems()]
15504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15505 
 
15506 
  def __eq__(self, other):
15507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15508 
 
15509 
  def __ne__(self, other):
15510 
    return not (self == other)
15511 
 
15512 
class deleteCampaign_args:
15513 
  """
15514 
  Attributes:
15515 
   - campaignId
15516 
  """
15517 
 
15518 
  thrift_spec = (
15519 
    None, # 0
15520 
    (1, TType.I64, 'campaignId', None, None, ), # 1
15521 
  )
15522 
 
15523 
  def __init__(self, campaignId=None,):
15524 
    self.campaignId = campaignId
15525 
 
15526 
  def read(self, iprot):
15527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15529 
      return
15530 
    iprot.readStructBegin()
15531 
    while True:
15532 
      (fname, ftype, fid) = iprot.readFieldBegin()
15533 
      if ftype == TType.STOP:
15534 
        break
15535 
      if fid == 1:
15536 
        if ftype == TType.I64:
15537 
          self.campaignId = iprot.readI64();
15538 
        else:
15539 
          iprot.skip(ftype)
15540 
      else:
15541 
        iprot.skip(ftype)
15542 
      iprot.readFieldEnd()
15543 
    iprot.readStructEnd()
15544 
 
15545 
  def write(self, oprot):
15546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15548 
      return
15549 
    oprot.writeStructBegin('deleteCampaign_args')
15550 
    if self.campaignId is not None:
15551 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
15552 
      oprot.writeI64(self.campaignId)
15553 
      oprot.writeFieldEnd()
15554 
    oprot.writeFieldStop()
15555 
    oprot.writeStructEnd()
15556 
 
15557 
  def validate(self):
15558 
    return
15559 
 
15560 
 
15561 
  def __repr__(self):
15562 
    L = ['%s=%r' % (key, value)
15563 
      for key, value in self.__dict__.iteritems()]
15564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15565 
 
15566 
  def __eq__(self, other):
15567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15568 
 
15569 
  def __ne__(self, other):
15570 
    return not (self == other)
15571 
 
15572 
class deleteCampaign_result:
15573 
 
15574 
  thrift_spec = (
15575 
  )
15576 
 
15577 
  def read(self, iprot):
15578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15580 
      return
15581 
    iprot.readStructBegin()
15582 
    while True:
15583 
      (fname, ftype, fid) = iprot.readFieldBegin()
15584 
      if ftype == TType.STOP:
15585 
        break
15586 
      else:
15587 
        iprot.skip(ftype)
15588 
      iprot.readFieldEnd()
15589 
    iprot.readStructEnd()
15590 
 
15591 
  def write(self, oprot):
15592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15594 
      return
15595 
    oprot.writeStructBegin('deleteCampaign_result')
15596 
    oprot.writeFieldStop()
15597 
    oprot.writeStructEnd()
15598 
 
15599 
  def validate(self):
15600 
    return
15601 
 
15602 
 
15603 
  def __repr__(self):
15604 
    L = ['%s=%r' % (key, value)
15605 
      for key, value in self.__dict__.iteritems()]
15606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15607 
 
15608 
  def __eq__(self, other):
15609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15610 
 
15611 
  def __ne__(self, other):
15612 
    return not (self == other)
15613 
 
15614 
class getAllCampaigns_args:
15615 
 
15616 
  thrift_spec = (
15617 
  )
15618 
 
15619 
  def read(self, iprot):
15620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15622 
      return
15623 
    iprot.readStructBegin()
15624 
    while True:
15625 
      (fname, ftype, fid) = iprot.readFieldBegin()
15626 
      if ftype == TType.STOP:
15627 
        break
15628 
      else:
15629 
        iprot.skip(ftype)
15630 
      iprot.readFieldEnd()
15631 
    iprot.readStructEnd()
15632 
 
15633 
  def write(self, oprot):
15634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15636 
      return
15637 
    oprot.writeStructBegin('getAllCampaigns_args')
15638 
    oprot.writeFieldStop()
15639 
    oprot.writeStructEnd()
15640 
 
15641 
  def validate(self):
15642 
    return
15643 
 
15644 
 
15645 
  def __repr__(self):
15646 
    L = ['%s=%r' % (key, value)
15647 
      for key, value in self.__dict__.iteritems()]
15648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15649 
 
15650 
  def __eq__(self, other):
15651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15652 
 
15653 
  def __ne__(self, other):
15654 
    return not (self == other)
15655 
 
15656 
class getAllCampaigns_result:
15657 
  """
15658 
  Attributes:
15659 
   - success
15660 
  """
15661 
 
15662 
  thrift_spec = (
15663 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15664 
  )
15665 
 
15666 
  def __init__(self, success=None,):
15667 
    self.success = success
15668 
 
15669 
  def read(self, iprot):
15670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15672 
      return
15673 
    iprot.readStructBegin()
15674 
    while True:
15675 
      (fname, ftype, fid) = iprot.readFieldBegin()
15676 
      if ftype == TType.STOP:
15677 
        break
15678 
      if fid == 0:
15679 
        if ftype == TType.LIST:
15680 
          self.success = []
8590 kshitij.so 15681 
          (_etype256, _size253) = iprot.readListBegin()
15682 
          for _i257 in xrange(_size253):
15683 
            _elem258 = iprot.readString();
15684 
            self.success.append(_elem258)
8579 kshitij.so 15685 
          iprot.readListEnd()
15686 
        else:
15687 
          iprot.skip(ftype)
15688 
      else:
15689 
        iprot.skip(ftype)
15690 
      iprot.readFieldEnd()
15691 
    iprot.readStructEnd()
15692 
 
15693 
  def write(self, oprot):
15694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15696 
      return
15697 
    oprot.writeStructBegin('getAllCampaigns_result')
15698 
    if self.success is not None:
15699 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15700 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 15701 
      for iter259 in self.success:
15702 
        oprot.writeString(iter259)
8579 kshitij.so 15703 
      oprot.writeListEnd()
15704 
      oprot.writeFieldEnd()
15705 
    oprot.writeFieldStop()
15706 
    oprot.writeStructEnd()
15707 
 
15708 
  def validate(self):
15709 
    return
15710 
 
15711 
 
15712 
  def __repr__(self):
15713 
    L = ['%s=%r' % (key, value)
15714 
      for key, value in self.__dict__.iteritems()]
15715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15716 
 
15717 
  def __eq__(self, other):
15718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15719 
 
15720 
  def __ne__(self, other):
15721 
    return not (self == other)
15722 
 
9155 kshitij.so 15723 
class getActiveBannersForMobileSite_args:
15724 
 
15725 
  thrift_spec = (
15726 
  )
15727 
 
15728 
  def read(self, iprot):
15729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15731 
      return
15732 
    iprot.readStructBegin()
15733 
    while True:
15734 
      (fname, ftype, fid) = iprot.readFieldBegin()
15735 
      if ftype == TType.STOP:
15736 
        break
15737 
      else:
15738 
        iprot.skip(ftype)
15739 
      iprot.readFieldEnd()
15740 
    iprot.readStructEnd()
15741 
 
15742 
  def write(self, oprot):
15743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15745 
      return
15746 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
15747 
    oprot.writeFieldStop()
15748 
    oprot.writeStructEnd()
15749 
 
15750 
  def validate(self):
15751 
    return
15752 
 
15753 
 
15754 
  def __repr__(self):
15755 
    L = ['%s=%r' % (key, value)
15756 
      for key, value in self.__dict__.iteritems()]
15757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15758 
 
15759 
  def __eq__(self, other):
15760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15761 
 
15762 
  def __ne__(self, other):
15763 
    return not (self == other)
15764 
 
15765 
class getActiveBannersForMobileSite_result:
15766 
  """
15767 
  Attributes:
15768 
   - success
15769 
  """
15770 
 
15771 
  thrift_spec = (
15772 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
15773 
  )
15774 
 
15775 
  def __init__(self, success=None,):
15776 
    self.success = success
15777 
 
15778 
  def read(self, iprot):
15779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15781 
      return
15782 
    iprot.readStructBegin()
15783 
    while True:
15784 
      (fname, ftype, fid) = iprot.readFieldBegin()
15785 
      if ftype == TType.STOP:
15786 
        break
15787 
      if fid == 0:
15788 
        if ftype == TType.MAP:
15789 
          self.success = {}
15790 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
15791 
          for _i264 in xrange(_size260):
15792 
            _key265 = iprot.readString();
15793 
            _val266 = []
15794 
            (_etype270, _size267) = iprot.readListBegin()
15795 
            for _i271 in xrange(_size267):
15796 
              _elem272 = Banner()
15797 
              _elem272.read(iprot)
15798 
              _val266.append(_elem272)
15799 
            iprot.readListEnd()
15800 
            self.success[_key265] = _val266
15801 
          iprot.readMapEnd()
15802 
        else:
15803 
          iprot.skip(ftype)
15804 
      else:
15805 
        iprot.skip(ftype)
15806 
      iprot.readFieldEnd()
15807 
    iprot.readStructEnd()
15808 
 
15809 
  def write(self, oprot):
15810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15812 
      return
15813 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
15814 
    if self.success is not None:
15815 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15816 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
15817 
      for kiter273,viter274 in self.success.items():
15818 
        oprot.writeString(kiter273)
15819 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
15820 
        for iter275 in viter274:
15821 
          iter275.write(oprot)
15822 
        oprot.writeListEnd()
15823 
      oprot.writeMapEnd()
15824 
      oprot.writeFieldEnd()
15825 
    oprot.writeFieldStop()
15826 
    oprot.writeStructEnd()
15827 
 
15828 
  def validate(self):
15829 
    return
15830 
 
15831 
 
15832 
  def __repr__(self):
15833 
    L = ['%s=%r' % (key, value)
15834 
      for key, value in self.__dict__.iteritems()]
15835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15836 
 
15837 
  def __eq__(self, other):
15838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15839 
 
15840 
  def __ne__(self, other):
15841 
    return not (self == other)
15842 
 
5944 mandeep.dh 15843 
class deleteSimilarItem_args:
15844 
  """
15845 
  Attributes:
15846 
   - itemId
15847 
   - catalogItemId
15848 
  """
15849 
 
15850 
  thrift_spec = (
15851 
    None, # 0
15852 
    (1, TType.I64, 'itemId', None, None, ), # 1
15853 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
15854 
  )
15855 
 
15856 
  def __init__(self, itemId=None, catalogItemId=None,):
15857 
    self.itemId = itemId
15858 
    self.catalogItemId = catalogItemId
15859 
 
15860 
  def read(self, iprot):
15861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15863 
      return
15864 
    iprot.readStructBegin()
15865 
    while True:
15866 
      (fname, ftype, fid) = iprot.readFieldBegin()
15867 
      if ftype == TType.STOP:
15868 
        break
15869 
      if fid == 1:
15870 
        if ftype == TType.I64:
15871 
          self.itemId = iprot.readI64();
15872 
        else:
15873 
          iprot.skip(ftype)
15874 
      elif fid == 2:
15875 
        if ftype == TType.I64:
15876 
          self.catalogItemId = iprot.readI64();
15877 
        else:
15878 
          iprot.skip(ftype)
15879 
      else:
15880 
        iprot.skip(ftype)
15881 
      iprot.readFieldEnd()
15882 
    iprot.readStructEnd()
15883 
 
15884 
  def write(self, oprot):
15885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15887 
      return
15888 
    oprot.writeStructBegin('deleteSimilarItem_args')
15889 
    if self.itemId is not None:
15890 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15891 
      oprot.writeI64(self.itemId)
15892 
      oprot.writeFieldEnd()
15893 
    if self.catalogItemId is not None:
15894 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
15895 
      oprot.writeI64(self.catalogItemId)
15896 
      oprot.writeFieldEnd()
15897 
    oprot.writeFieldStop()
15898 
    oprot.writeStructEnd()
15899 
 
15900 
  def validate(self):
15901 
    return
15902 
 
15903 
 
15904 
  def __repr__(self):
15905 
    L = ['%s=%r' % (key, value)
15906 
      for key, value in self.__dict__.iteritems()]
15907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15908 
 
15909 
  def __eq__(self, other):
15910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15911 
 
15912 
  def __ne__(self, other):
15913 
    return not (self == other)
15914 
 
15915 
class deleteSimilarItem_result:
15916 
  """
15917 
  Attributes:
15918 
   - success
15919 
   - cex
15920 
  """
15921 
 
15922 
  thrift_spec = (
15923 
    (0, TType.BOOL, 'success', None, None, ), # 0
15924 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15925 
  )
15926 
 
15927 
  def __init__(self, success=None, cex=None,):
15928 
    self.success = success
15929 
    self.cex = cex
15930 
 
15931 
  def read(self, iprot):
15932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15934 
      return
15935 
    iprot.readStructBegin()
15936 
    while True:
15937 
      (fname, ftype, fid) = iprot.readFieldBegin()
15938 
      if ftype == TType.STOP:
15939 
        break
15940 
      if fid == 0:
15941 
        if ftype == TType.BOOL:
15942 
          self.success = iprot.readBool();
15943 
        else:
15944 
          iprot.skip(ftype)
15945 
      elif fid == 1:
15946 
        if ftype == TType.STRUCT:
15947 
          self.cex = CatalogServiceException()
15948 
          self.cex.read(iprot)
15949 
        else:
15950 
          iprot.skip(ftype)
15951 
      else:
15952 
        iprot.skip(ftype)
15953 
      iprot.readFieldEnd()
15954 
    iprot.readStructEnd()
15955 
 
15956 
  def write(self, oprot):
15957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15959 
      return
15960 
    oprot.writeStructBegin('deleteSimilarItem_result')
15961 
    if self.success is not None:
15962 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15963 
      oprot.writeBool(self.success)
15964 
      oprot.writeFieldEnd()
15965 
    if self.cex is not None:
15966 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15967 
      self.cex.write(oprot)
15968 
      oprot.writeFieldEnd()
15969 
    oprot.writeFieldStop()
15970 
    oprot.writeStructEnd()
15971 
 
15972 
  def validate(self):
15973 
    return
15974 
 
15975 
 
15976 
  def __repr__(self):
15977 
    L = ['%s=%r' % (key, value)
15978 
      for key, value in self.__dict__.iteritems()]
15979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15980 
 
15981 
  def __eq__(self, other):
15982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15983 
 
15984 
  def __ne__(self, other):
15985 
    return not (self == other)
15986 
 
15987 
class checkSimilarItem_args:
15988 
  """
15989 
  Attributes:
15990 
   - brand
15991 
   - modelNumber
15992 
   - modelName
15993 
   - color
15994 
  """
15995 
 
15996 
  thrift_spec = (
15997 
    None, # 0
15998 
    (1, TType.STRING, 'brand', None, None, ), # 1
15999 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
16000 
    (3, TType.STRING, 'modelName', None, None, ), # 3
16001 
    (4, TType.STRING, 'color', None, None, ), # 4
16002 
  )
16003 
 
16004 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
16005 
    self.brand = brand
16006 
    self.modelNumber = modelNumber
16007 
    self.modelName = modelName
16008 
    self.color = color
16009 
 
16010 
  def read(self, iprot):
16011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16013 
      return
16014 
    iprot.readStructBegin()
16015 
    while True:
16016 
      (fname, ftype, fid) = iprot.readFieldBegin()
16017 
      if ftype == TType.STOP:
16018 
        break
16019 
      if fid == 1:
16020 
        if ftype == TType.STRING:
16021 
          self.brand = iprot.readString();
16022 
        else:
16023 
          iprot.skip(ftype)
16024 
      elif fid == 2:
16025 
        if ftype == TType.STRING:
16026 
          self.modelNumber = iprot.readString();
16027 
        else:
16028 
          iprot.skip(ftype)
16029 
      elif fid == 3:
16030 
        if ftype == TType.STRING:
16031 
          self.modelName = iprot.readString();
16032 
        else:
16033 
          iprot.skip(ftype)
16034 
      elif fid == 4:
16035 
        if ftype == TType.STRING:
16036 
          self.color = iprot.readString();
16037 
        else:
16038 
          iprot.skip(ftype)
16039 
      else:
16040 
        iprot.skip(ftype)
16041 
      iprot.readFieldEnd()
16042 
    iprot.readStructEnd()
16043 
 
16044 
  def write(self, oprot):
16045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16047 
      return
16048 
    oprot.writeStructBegin('checkSimilarItem_args')
16049 
    if self.brand is not None:
16050 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
16051 
      oprot.writeString(self.brand)
16052 
      oprot.writeFieldEnd()
16053 
    if self.modelNumber is not None:
16054 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
16055 
      oprot.writeString(self.modelNumber)
16056 
      oprot.writeFieldEnd()
16057 
    if self.modelName is not None:
16058 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
16059 
      oprot.writeString(self.modelName)
16060 
      oprot.writeFieldEnd()
16061 
    if self.color is not None:
16062 
      oprot.writeFieldBegin('color', TType.STRING, 4)
16063 
      oprot.writeString(self.color)
16064 
      oprot.writeFieldEnd()
16065 
    oprot.writeFieldStop()
16066 
    oprot.writeStructEnd()
16067 
 
16068 
  def validate(self):
16069 
    return
16070 
 
16071 
 
16072 
  def __repr__(self):
16073 
    L = ['%s=%r' % (key, value)
16074 
      for key, value in self.__dict__.iteritems()]
16075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16076 
 
16077 
  def __eq__(self, other):
16078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16079 
 
16080 
  def __ne__(self, other):
16081 
    return not (self == other)
16082 
 
16083 
class checkSimilarItem_result:
16084 
  """
16085 
  Attributes:
16086 
   - success
16087 
  """
16088 
 
16089 
  thrift_spec = (
16090 
    (0, TType.I64, 'success', None, None, ), # 0
16091 
  )
16092 
 
16093 
  def __init__(self, success=None,):
16094 
    self.success = success
16095 
 
16096 
  def read(self, iprot):
16097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16099 
      return
16100 
    iprot.readStructBegin()
16101 
    while True:
16102 
      (fname, ftype, fid) = iprot.readFieldBegin()
16103 
      if ftype == TType.STOP:
16104 
        break
16105 
      if fid == 0:
16106 
        if ftype == TType.I64:
16107 
          self.success = iprot.readI64();
16108 
        else:
16109 
          iprot.skip(ftype)
16110 
      else:
16111 
        iprot.skip(ftype)
16112 
      iprot.readFieldEnd()
16113 
    iprot.readStructEnd()
16114 
 
16115 
  def write(self, oprot):
16116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16118 
      return
16119 
    oprot.writeStructBegin('checkSimilarItem_result')
16120 
    if self.success is not None:
16121 
      oprot.writeFieldBegin('success', TType.I64, 0)
16122 
      oprot.writeI64(self.success)
16123 
      oprot.writeFieldEnd()
16124 
    oprot.writeFieldStop()
16125 
    oprot.writeStructEnd()
16126 
 
16127 
  def validate(self):
16128 
    return
16129 
 
16130 
 
16131 
  def __repr__(self):
16132 
    L = ['%s=%r' % (key, value)
16133 
      for key, value in self.__dict__.iteritems()]
16134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16135 
 
16136 
  def __eq__(self, other):
16137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16138 
 
16139 
  def __ne__(self, other):
16140 
    return not (self == other)
16141 
 
16142 
class validateRiskyStatus_args:
16143 
  """
16144 
  Attributes:
16145 
   - itemId
16146 
  """
16147 
 
16148 
  thrift_spec = (
16149 
    None, # 0
16150 
    (1, TType.I64, 'itemId', None, None, ), # 1
16151 
  )
16152 
 
16153 
  def __init__(self, itemId=None,):
16154 
    self.itemId = itemId
16155 
 
16156 
  def read(self, iprot):
16157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16159 
      return
16160 
    iprot.readStructBegin()
16161 
    while True:
16162 
      (fname, ftype, fid) = iprot.readFieldBegin()
16163 
      if ftype == TType.STOP:
16164 
        break
16165 
      if fid == 1:
16166 
        if ftype == TType.I64:
16167 
          self.itemId = iprot.readI64();
16168 
        else:
16169 
          iprot.skip(ftype)
16170 
      else:
16171 
        iprot.skip(ftype)
16172 
      iprot.readFieldEnd()
16173 
    iprot.readStructEnd()
16174 
 
16175 
  def write(self, oprot):
16176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16178 
      return
16179 
    oprot.writeStructBegin('validateRiskyStatus_args')
16180 
    if self.itemId is not None:
16181 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16182 
      oprot.writeI64(self.itemId)
16183 
      oprot.writeFieldEnd()
16184 
    oprot.writeFieldStop()
16185 
    oprot.writeStructEnd()
16186 
 
16187 
  def validate(self):
16188 
    return
16189 
 
16190 
 
16191 
  def __repr__(self):
16192 
    L = ['%s=%r' % (key, value)
16193 
      for key, value in self.__dict__.iteritems()]
16194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16195 
 
16196 
  def __eq__(self, other):
16197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16198 
 
16199 
  def __ne__(self, other):
16200 
    return not (self == other)
16201 
 
16202 
class validateRiskyStatus_result:
16203 
 
16204 
  thrift_spec = (
16205 
  )
16206 
 
16207 
  def read(self, iprot):
16208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16210 
      return
16211 
    iprot.readStructBegin()
16212 
    while True:
16213 
      (fname, ftype, fid) = iprot.readFieldBegin()
16214 
      if ftype == TType.STOP:
16215 
        break
16216 
      else:
16217 
        iprot.skip(ftype)
16218 
      iprot.readFieldEnd()
16219 
    iprot.readStructEnd()
16220 
 
16221 
  def write(self, oprot):
16222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16224 
      return
16225 
    oprot.writeStructBegin('validateRiskyStatus_result')
16226 
    oprot.writeFieldStop()
16227 
    oprot.writeStructEnd()
16228 
 
16229 
  def validate(self):
16230 
    return
16231 
 
16232 
 
16233 
  def __repr__(self):
16234 
    L = ['%s=%r' % (key, value)
16235 
      for key, value in self.__dict__.iteritems()]
16236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16237 
 
16238 
  def __eq__(self, other):
16239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16240 
 
16241 
  def __ne__(self, other):
16242 
    return not (self == other)
16243 
 
16244 
class changeItemRiskyFlag_args:
16245 
  """
16246 
  Attributes:
16247 
   - itemId
16248 
   - risky
16249 
  """
16250 
 
16251 
  thrift_spec = (
16252 
    None, # 0
16253 
    (1, TType.I64, 'itemId', None, None, ), # 1
16254 
    (2, TType.BOOL, 'risky', None, None, ), # 2
16255 
  )
16256 
 
16257 
  def __init__(self, itemId=None, risky=None,):
16258 
    self.itemId = itemId
16259 
    self.risky = risky
16260 
 
16261 
  def read(self, iprot):
16262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16264 
      return
16265 
    iprot.readStructBegin()
16266 
    while True:
16267 
      (fname, ftype, fid) = iprot.readFieldBegin()
16268 
      if ftype == TType.STOP:
16269 
        break
16270 
      if fid == 1:
16271 
        if ftype == TType.I64:
16272 
          self.itemId = iprot.readI64();
16273 
        else:
16274 
          iprot.skip(ftype)
16275 
      elif fid == 2:
16276 
        if ftype == TType.BOOL:
16277 
          self.risky = iprot.readBool();
16278 
        else:
16279 
          iprot.skip(ftype)
16280 
      else:
16281 
        iprot.skip(ftype)
16282 
      iprot.readFieldEnd()
16283 
    iprot.readStructEnd()
16284 
 
16285 
  def write(self, oprot):
16286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16288 
      return
16289 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
16290 
    if self.itemId is not None:
16291 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16292 
      oprot.writeI64(self.itemId)
16293 
      oprot.writeFieldEnd()
16294 
    if self.risky is not None:
16295 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
16296 
      oprot.writeBool(self.risky)
16297 
      oprot.writeFieldEnd()
16298 
    oprot.writeFieldStop()
16299 
    oprot.writeStructEnd()
16300 
 
16301 
  def validate(self):
16302 
    return
16303 
 
16304 
 
16305 
  def __repr__(self):
16306 
    L = ['%s=%r' % (key, value)
16307 
      for key, value in self.__dict__.iteritems()]
16308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16309 
 
16310 
  def __eq__(self, other):
16311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16312 
 
16313 
  def __ne__(self, other):
16314 
    return not (self == other)
16315 
 
16316 
class changeItemRiskyFlag_result:
16317 
 
16318 
  thrift_spec = (
16319 
  )
16320 
 
16321 
  def read(self, iprot):
16322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16324 
      return
16325 
    iprot.readStructBegin()
16326 
    while True:
16327 
      (fname, ftype, fid) = iprot.readFieldBegin()
16328 
      if ftype == TType.STOP:
16329 
        break
16330 
      else:
16331 
        iprot.skip(ftype)
16332 
      iprot.readFieldEnd()
16333 
    iprot.readStructEnd()
16334 
 
16335 
  def write(self, oprot):
16336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16338 
      return
16339 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
16340 
    oprot.writeFieldStop()
16341 
    oprot.writeStructEnd()
16342 
 
16343 
  def validate(self):
16344 
    return
16345 
 
16346 
 
16347 
  def __repr__(self):
16348 
    L = ['%s=%r' % (key, value)
16349 
      for key, value in self.__dict__.iteritems()]
16350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16351 
 
16352 
  def __eq__(self, other):
16353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16354 
 
16355 
  def __ne__(self, other):
16356 
    return not (self == other)
16357 
 
16358 
class getItemsByRiskyFlag_args:
16359 
 
16360 
  thrift_spec = (
16361 
  )
16362 
 
16363 
  def read(self, iprot):
16364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16366 
      return
16367 
    iprot.readStructBegin()
16368 
    while True:
16369 
      (fname, ftype, fid) = iprot.readFieldBegin()
16370 
      if ftype == TType.STOP:
16371 
        break
16372 
      else:
16373 
        iprot.skip(ftype)
16374 
      iprot.readFieldEnd()
16375 
    iprot.readStructEnd()
16376 
 
16377 
  def write(self, oprot):
16378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16380 
      return
16381 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
16382 
    oprot.writeFieldStop()
16383 
    oprot.writeStructEnd()
16384 
 
16385 
  def validate(self):
16386 
    return
16387 
 
16388 
 
16389 
  def __repr__(self):
16390 
    L = ['%s=%r' % (key, value)
16391 
      for key, value in self.__dict__.iteritems()]
16392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16393 
 
16394 
  def __eq__(self, other):
16395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16396 
 
16397 
  def __ne__(self, other):
16398 
    return not (self == other)
16399 
 
16400 
class getItemsByRiskyFlag_result:
16401 
  """
16402 
  Attributes:
16403 
   - success
16404 
  """
16405 
 
16406 
  thrift_spec = (
16407 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16408 
  )
16409 
 
16410 
  def __init__(self, success=None,):
16411 
    self.success = success
16412 
 
16413 
  def read(self, iprot):
16414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16416 
      return
16417 
    iprot.readStructBegin()
16418 
    while True:
16419 
      (fname, ftype, fid) = iprot.readFieldBegin()
16420 
      if ftype == TType.STOP:
16421 
        break
16422 
      if fid == 0:
16423 
        if ftype == TType.LIST:
16424 
          self.success = []
9155 kshitij.so 16425 
          (_etype279, _size276) = iprot.readListBegin()
16426 
          for _i280 in xrange(_size276):
16427 
            _elem281 = Item()
16428 
            _elem281.read(iprot)
16429 
            self.success.append(_elem281)
5944 mandeep.dh 16430 
          iprot.readListEnd()
16431 
        else:
16432 
          iprot.skip(ftype)
16433 
      else:
16434 
        iprot.skip(ftype)
16435 
      iprot.readFieldEnd()
16436 
    iprot.readStructEnd()
16437 
 
16438 
  def write(self, oprot):
16439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16441 
      return
16442 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
16443 
    if self.success is not None:
16444 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16445 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16446 
      for iter282 in self.success:
16447 
        iter282.write(oprot)
5944 mandeep.dh 16448 
      oprot.writeListEnd()
16449 
      oprot.writeFieldEnd()
16450 
    oprot.writeFieldStop()
16451 
    oprot.writeStructEnd()
16452 
 
16453 
  def validate(self):
16454 
    return
16455 
 
16456 
 
16457 
  def __repr__(self):
16458 
    L = ['%s=%r' % (key, value)
16459 
      for key, value in self.__dict__.iteritems()]
16460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16461 
 
16462 
  def __eq__(self, other):
16463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16464 
 
16465 
  def __ne__(self, other):
16466 
    return not (self == other)
16467 
 
16468 
class getItemsForMasterSheet_args:
16469 
  """
16470 
  Attributes:
16471 
   - category
16472 
   - brand
16473 
  """
16474 
 
16475 
  thrift_spec = (
16476 
    None, # 0
16477 
    (1, TType.STRING, 'category', None, None, ), # 1
16478 
    (2, TType.STRING, 'brand', None, None, ), # 2
16479 
  )
16480 
 
16481 
  def __init__(self, category=None, brand=None,):
16482 
    self.category = category
16483 
    self.brand = brand
16484 
 
16485 
  def read(self, iprot):
16486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16488 
      return
16489 
    iprot.readStructBegin()
16490 
    while True:
16491 
      (fname, ftype, fid) = iprot.readFieldBegin()
16492 
      if ftype == TType.STOP:
16493 
        break
16494 
      if fid == 1:
16495 
        if ftype == TType.STRING:
16496 
          self.category = iprot.readString();
16497 
        else:
16498 
          iprot.skip(ftype)
16499 
      elif fid == 2:
16500 
        if ftype == TType.STRING:
16501 
          self.brand = iprot.readString();
16502 
        else:
16503 
          iprot.skip(ftype)
16504 
      else:
16505 
        iprot.skip(ftype)
16506 
      iprot.readFieldEnd()
16507 
    iprot.readStructEnd()
16508 
 
16509 
  def write(self, oprot):
16510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16512 
      return
16513 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
16514 
    if self.category is not None:
16515 
      oprot.writeFieldBegin('category', TType.STRING, 1)
16516 
      oprot.writeString(self.category)
16517 
      oprot.writeFieldEnd()
16518 
    if self.brand is not None:
16519 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
16520 
      oprot.writeString(self.brand)
16521 
      oprot.writeFieldEnd()
16522 
    oprot.writeFieldStop()
16523 
    oprot.writeStructEnd()
16524 
 
16525 
  def validate(self):
16526 
    return
16527 
 
16528 
 
16529 
  def __repr__(self):
16530 
    L = ['%s=%r' % (key, value)
16531 
      for key, value in self.__dict__.iteritems()]
16532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16533 
 
16534 
  def __eq__(self, other):
16535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16536 
 
16537 
  def __ne__(self, other):
16538 
    return not (self == other)
16539 
 
16540 
class getItemsForMasterSheet_result:
16541 
  """
16542 
  Attributes:
16543 
   - success
16544 
  """
16545 
 
16546 
  thrift_spec = (
16547 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16548 
  )
16549 
 
16550 
  def __init__(self, success=None,):
16551 
    self.success = success
16552 
 
16553 
  def read(self, iprot):
16554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16556 
      return
16557 
    iprot.readStructBegin()
16558 
    while True:
16559 
      (fname, ftype, fid) = iprot.readFieldBegin()
16560 
      if ftype == TType.STOP:
16561 
        break
16562 
      if fid == 0:
16563 
        if ftype == TType.LIST:
16564 
          self.success = []
9155 kshitij.so 16565 
          (_etype286, _size283) = iprot.readListBegin()
16566 
          for _i287 in xrange(_size283):
16567 
            _elem288 = Item()
16568 
            _elem288.read(iprot)
16569 
            self.success.append(_elem288)
5944 mandeep.dh 16570 
          iprot.readListEnd()
16571 
        else:
16572 
          iprot.skip(ftype)
16573 
      else:
16574 
        iprot.skip(ftype)
16575 
      iprot.readFieldEnd()
16576 
    iprot.readStructEnd()
16577 
 
16578 
  def write(self, oprot):
16579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16581 
      return
16582 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
16583 
    if self.success is not None:
16584 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16585 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16586 
      for iter289 in self.success:
16587 
        iter289.write(oprot)
5944 mandeep.dh 16588 
      oprot.writeListEnd()
16589 
      oprot.writeFieldEnd()
16590 
    oprot.writeFieldStop()
16591 
    oprot.writeStructEnd()
16592 
 
16593 
  def validate(self):
16594 
    return
16595 
 
16596 
 
16597 
  def __repr__(self):
16598 
    L = ['%s=%r' % (key, value)
16599 
      for key, value in self.__dict__.iteritems()]
16600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16601 
 
16602 
  def __eq__(self, other):
16603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16604 
 
16605 
  def __ne__(self, other):
16606 
    return not (self == other)
16607 
 
16608 
class getSimilarItemsCatalogIds_args:
16609 
  """
16610 
  Attributes:
16611 
   - beginIndex
16612 
   - totalItems
16613 
   - itemId
16614 
  """
16615 
 
16616 
  thrift_spec = (
16617 
    None, # 0
16618 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
16619 
    (2, TType.I64, 'totalItems', None, None, ), # 2
16620 
    (3, TType.I64, 'itemId', None, None, ), # 3
16621 
  )
16622 
 
16623 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
16624 
    self.beginIndex = beginIndex
16625 
    self.totalItems = totalItems
16626 
    self.itemId = itemId
16627 
 
16628 
  def read(self, iprot):
16629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16631 
      return
16632 
    iprot.readStructBegin()
16633 
    while True:
16634 
      (fname, ftype, fid) = iprot.readFieldBegin()
16635 
      if ftype == TType.STOP:
16636 
        break
16637 
      if fid == 1:
16638 
        if ftype == TType.I64:
16639 
          self.beginIndex = iprot.readI64();
16640 
        else:
16641 
          iprot.skip(ftype)
16642 
      elif fid == 2:
16643 
        if ftype == TType.I64:
16644 
          self.totalItems = iprot.readI64();
16645 
        else:
16646 
          iprot.skip(ftype)
16647 
      elif fid == 3:
16648 
        if ftype == TType.I64:
16649 
          self.itemId = iprot.readI64();
16650 
        else:
16651 
          iprot.skip(ftype)
16652 
      else:
16653 
        iprot.skip(ftype)
16654 
      iprot.readFieldEnd()
16655 
    iprot.readStructEnd()
16656 
 
16657 
  def write(self, oprot):
16658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16660 
      return
16661 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
16662 
    if self.beginIndex is not None:
16663 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
16664 
      oprot.writeI64(self.beginIndex)
16665 
      oprot.writeFieldEnd()
16666 
    if self.totalItems is not None:
16667 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
16668 
      oprot.writeI64(self.totalItems)
16669 
      oprot.writeFieldEnd()
16670 
    if self.itemId is not None:
16671 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
16672 
      oprot.writeI64(self.itemId)
16673 
      oprot.writeFieldEnd()
16674 
    oprot.writeFieldStop()
16675 
    oprot.writeStructEnd()
16676 
 
16677 
  def validate(self):
16678 
    return
16679 
 
16680 
 
16681 
  def __repr__(self):
16682 
    L = ['%s=%r' % (key, value)
16683 
      for key, value in self.__dict__.iteritems()]
16684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16685 
 
16686 
  def __eq__(self, other):
16687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16688 
 
16689 
  def __ne__(self, other):
16690 
    return not (self == other)
16691 
 
16692 
class getSimilarItemsCatalogIds_result:
16693 
  """
16694 
  Attributes:
16695 
   - success
16696 
  """
16697 
 
16698 
  thrift_spec = (
16699 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
16700 
  )
16701 
 
16702 
  def __init__(self, success=None,):
16703 
    self.success = success
16704 
 
16705 
  def read(self, iprot):
16706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16708 
      return
16709 
    iprot.readStructBegin()
16710 
    while True:
16711 
      (fname, ftype, fid) = iprot.readFieldBegin()
16712 
      if ftype == TType.STOP:
16713 
        break
16714 
      if fid == 0:
16715 
        if ftype == TType.LIST:
16716 
          self.success = []
9155 kshitij.so 16717 
          (_etype293, _size290) = iprot.readListBegin()
16718 
          for _i294 in xrange(_size290):
16719 
            _elem295 = iprot.readI64();
16720 
            self.success.append(_elem295)
5944 mandeep.dh 16721 
          iprot.readListEnd()
16722 
        else:
16723 
          iprot.skip(ftype)
16724 
      else:
16725 
        iprot.skip(ftype)
16726 
      iprot.readFieldEnd()
16727 
    iprot.readStructEnd()
16728 
 
16729 
  def write(self, oprot):
16730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16732 
      return
16733 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
16734 
    if self.success is not None:
16735 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16736 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 16737 
      for iter296 in self.success:
16738 
        oprot.writeI64(iter296)
5944 mandeep.dh 16739 
      oprot.writeListEnd()
16740 
      oprot.writeFieldEnd()
16741 
    oprot.writeFieldStop()
16742 
    oprot.writeStructEnd()
16743 
 
16744 
  def validate(self):
16745 
    return
16746 
 
16747 
 
16748 
  def __repr__(self):
16749 
    L = ['%s=%r' % (key, value)
16750 
      for key, value in self.__dict__.iteritems()]
16751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16752 
 
16753 
  def __eq__(self, other):
16754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16755 
 
16756 
  def __ne__(self, other):
16757 
    return not (self == other)
16758 
 
16759 
class addProductNotification_args:
16760 
  """
16761 
  Attributes:
16762 
   - itemId
16763 
   - email
16764 
  """
16765 
 
16766 
  thrift_spec = None
16767 
  def __init__(self, itemId=None, email=None,):
16768 
    self.itemId = itemId
16769 
    self.email = email
16770 
 
16771 
  def read(self, iprot):
16772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16774 
      return
16775 
    iprot.readStructBegin()
16776 
    while True:
16777 
      (fname, ftype, fid) = iprot.readFieldBegin()
16778 
      if ftype == TType.STOP:
16779 
        break
16780 
      if fid == -1:
16781 
        if ftype == TType.I64:
16782 
          self.itemId = iprot.readI64();
16783 
        else:
16784 
          iprot.skip(ftype)
16785 
      elif fid == -2:
16786 
        if ftype == TType.STRING:
16787 
          self.email = iprot.readString();
16788 
        else:
16789 
          iprot.skip(ftype)
16790 
      else:
16791 
        iprot.skip(ftype)
16792 
      iprot.readFieldEnd()
16793 
    iprot.readStructEnd()
16794 
 
16795 
  def write(self, oprot):
16796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16798 
      return
16799 
    oprot.writeStructBegin('addProductNotification_args')
16800 
    if self.email is not None:
16801 
      oprot.writeFieldBegin('email', TType.STRING, -2)
16802 
      oprot.writeString(self.email)
16803 
      oprot.writeFieldEnd()
16804 
    if self.itemId is not None:
16805 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
16806 
      oprot.writeI64(self.itemId)
16807 
      oprot.writeFieldEnd()
16808 
    oprot.writeFieldStop()
16809 
    oprot.writeStructEnd()
16810 
 
16811 
  def validate(self):
16812 
    return
16813 
 
16814 
 
16815 
  def __repr__(self):
16816 
    L = ['%s=%r' % (key, value)
16817 
      for key, value in self.__dict__.iteritems()]
16818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16819 
 
16820 
  def __eq__(self, other):
16821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16822 
 
16823 
  def __ne__(self, other):
16824 
    return not (self == other)
16825 
 
16826 
class addProductNotification_result:
16827 
  """
16828 
  Attributes:
16829 
   - success
16830 
  """
16831 
 
16832 
  thrift_spec = (
16833 
    (0, TType.BOOL, 'success', None, None, ), # 0
16834 
  )
16835 
 
16836 
  def __init__(self, success=None,):
16837 
    self.success = success
16838 
 
16839 
  def read(self, iprot):
16840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16842 
      return
16843 
    iprot.readStructBegin()
16844 
    while True:
16845 
      (fname, ftype, fid) = iprot.readFieldBegin()
16846 
      if ftype == TType.STOP:
16847 
        break
16848 
      if fid == 0:
16849 
        if ftype == TType.BOOL:
16850 
          self.success = iprot.readBool();
16851 
        else:
16852 
          iprot.skip(ftype)
16853 
      else:
16854 
        iprot.skip(ftype)
16855 
      iprot.readFieldEnd()
16856 
    iprot.readStructEnd()
16857 
 
16858 
  def write(self, oprot):
16859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16861 
      return
16862 
    oprot.writeStructBegin('addProductNotification_result')
16863 
    if self.success is not None:
16864 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16865 
      oprot.writeBool(self.success)
16866 
      oprot.writeFieldEnd()
16867 
    oprot.writeFieldStop()
16868 
    oprot.writeStructEnd()
16869 
 
16870 
  def validate(self):
16871 
    return
16872 
 
16873 
 
16874 
  def __repr__(self):
16875 
    L = ['%s=%r' % (key, value)
16876 
      for key, value in self.__dict__.iteritems()]
16877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16878 
 
16879 
  def __eq__(self, other):
16880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16881 
 
16882 
  def __ne__(self, other):
16883 
    return not (self == other)
16884 
 
16885 
class sendProductNotifications_args:
16886 
 
16887 
  thrift_spec = (
16888 
  )
16889 
 
16890 
  def read(self, iprot):
16891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16893 
      return
16894 
    iprot.readStructBegin()
16895 
    while True:
16896 
      (fname, ftype, fid) = iprot.readFieldBegin()
16897 
      if ftype == TType.STOP:
16898 
        break
16899 
      else:
16900 
        iprot.skip(ftype)
16901 
      iprot.readFieldEnd()
16902 
    iprot.readStructEnd()
16903 
 
16904 
  def write(self, oprot):
16905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16907 
      return
16908 
    oprot.writeStructBegin('sendProductNotifications_args')
16909 
    oprot.writeFieldStop()
16910 
    oprot.writeStructEnd()
16911 
 
16912 
  def validate(self):
16913 
    return
16914 
 
16915 
 
16916 
  def __repr__(self):
16917 
    L = ['%s=%r' % (key, value)
16918 
      for key, value in self.__dict__.iteritems()]
16919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16920 
 
16921 
  def __eq__(self, other):
16922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16923 
 
16924 
  def __ne__(self, other):
16925 
    return not (self == other)
16926 
 
16927 
class sendProductNotifications_result:
16928 
  """
16929 
  Attributes:
16930 
   - success
16931 
  """
16932 
 
16933 
  thrift_spec = (
16934 
    (0, TType.BOOL, 'success', None, None, ), # 0
16935 
  )
16936 
 
16937 
  def __init__(self, success=None,):
16938 
    self.success = success
16939 
 
16940 
  def read(self, iprot):
16941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16943 
      return
16944 
    iprot.readStructBegin()
16945 
    while True:
16946 
      (fname, ftype, fid) = iprot.readFieldBegin()
16947 
      if ftype == TType.STOP:
16948 
        break
16949 
      if fid == 0:
16950 
        if ftype == TType.BOOL:
16951 
          self.success = iprot.readBool();
16952 
        else:
16953 
          iprot.skip(ftype)
16954 
      else:
16955 
        iprot.skip(ftype)
16956 
      iprot.readFieldEnd()
16957 
    iprot.readStructEnd()
16958 
 
16959 
  def write(self, oprot):
16960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16962 
      return
16963 
    oprot.writeStructBegin('sendProductNotifications_result')
16964 
    if self.success is not None:
16965 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16966 
      oprot.writeBool(self.success)
16967 
      oprot.writeFieldEnd()
16968 
    oprot.writeFieldStop()
16969 
    oprot.writeStructEnd()
16970 
 
16971 
  def validate(self):
16972 
    return
16973 
 
16974 
 
16975 
  def __repr__(self):
16976 
    L = ['%s=%r' % (key, value)
16977 
      for key, value in self.__dict__.iteritems()]
16978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16979 
 
16980 
  def __eq__(self, other):
16981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16982 
 
16983 
  def __ne__(self, other):
16984 
    return not (self == other)
16985 
 
16986 
class getAllBrandsByCategory_args:
16987 
  """
16988 
  Attributes:
16989 
   - categoryId
16990 
  """
16991 
 
16992 
  thrift_spec = (
16993 
    None, # 0
16994 
    (1, TType.I64, 'categoryId', None, None, ), # 1
16995 
  )
16996 
 
16997 
  def __init__(self, categoryId=None,):
16998 
    self.categoryId = categoryId
16999 
 
17000 
  def read(self, iprot):
17001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17003 
      return
17004 
    iprot.readStructBegin()
17005 
    while True:
17006 
      (fname, ftype, fid) = iprot.readFieldBegin()
17007 
      if ftype == TType.STOP:
17008 
        break
17009 
      if fid == 1:
17010 
        if ftype == TType.I64:
17011 
          self.categoryId = iprot.readI64();
17012 
        else:
17013 
          iprot.skip(ftype)
17014 
      else:
17015 
        iprot.skip(ftype)
17016 
      iprot.readFieldEnd()
17017 
    iprot.readStructEnd()
17018 
 
17019 
  def write(self, oprot):
17020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17022 
      return
17023 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
17024 
    if self.categoryId is not None:
17025 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
17026 
      oprot.writeI64(self.categoryId)
17027 
      oprot.writeFieldEnd()
17028 
    oprot.writeFieldStop()
17029 
    oprot.writeStructEnd()
17030 
 
17031 
  def validate(self):
17032 
    return
17033 
 
17034 
 
17035 
  def __repr__(self):
17036 
    L = ['%s=%r' % (key, value)
17037 
      for key, value in self.__dict__.iteritems()]
17038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17039 
 
17040 
  def __eq__(self, other):
17041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17042 
 
17043 
  def __ne__(self, other):
17044 
    return not (self == other)
17045 
 
17046 
class getAllBrandsByCategory_result:
17047 
  """
17048 
  Attributes:
17049 
   - success
17050 
  """
17051 
 
17052 
  thrift_spec = (
17053 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
17054 
  )
17055 
 
17056 
  def __init__(self, success=None,):
17057 
    self.success = success
17058 
 
17059 
  def read(self, iprot):
17060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17062 
      return
17063 
    iprot.readStructBegin()
17064 
    while True:
17065 
      (fname, ftype, fid) = iprot.readFieldBegin()
17066 
      if ftype == TType.STOP:
17067 
        break
17068 
      if fid == 0:
17069 
        if ftype == TType.LIST:
17070 
          self.success = []
9155 kshitij.so 17071 
          (_etype300, _size297) = iprot.readListBegin()
17072 
          for _i301 in xrange(_size297):
17073 
            _elem302 = iprot.readString();
17074 
            self.success.append(_elem302)
5944 mandeep.dh 17075 
          iprot.readListEnd()
17076 
        else:
17077 
          iprot.skip(ftype)
17078 
      else:
17079 
        iprot.skip(ftype)
17080 
      iprot.readFieldEnd()
17081 
    iprot.readStructEnd()
17082 
 
17083 
  def write(self, oprot):
17084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17086 
      return
17087 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
17088 
    if self.success is not None:
17089 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17090 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 17091 
      for iter303 in self.success:
17092 
        oprot.writeString(iter303)
5944 mandeep.dh 17093 
      oprot.writeListEnd()
17094 
      oprot.writeFieldEnd()
17095 
    oprot.writeFieldStop()
17096 
    oprot.writeStructEnd()
17097 
 
17098 
  def validate(self):
17099 
    return
17100 
 
17101 
 
17102 
  def __repr__(self):
17103 
    L = ['%s=%r' % (key, value)
17104 
      for key, value in self.__dict__.iteritems()]
17105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17106 
 
17107 
  def __eq__(self, other):
17108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17109 
 
17110 
  def __ne__(self, other):
17111 
    return not (self == other)
17112 
 
17113 
class getAllBrands_args:
17114 
 
17115 
  thrift_spec = (
17116 
  )
17117 
 
17118 
  def read(self, iprot):
17119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17121 
      return
17122 
    iprot.readStructBegin()
17123 
    while True:
17124 
      (fname, ftype, fid) = iprot.readFieldBegin()
17125 
      if ftype == TType.STOP:
17126 
        break
17127 
      else:
17128 
        iprot.skip(ftype)
17129 
      iprot.readFieldEnd()
17130 
    iprot.readStructEnd()
17131 
 
17132 
  def write(self, oprot):
17133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17135 
      return
17136 
    oprot.writeStructBegin('getAllBrands_args')
17137 
    oprot.writeFieldStop()
17138 
    oprot.writeStructEnd()
17139 
 
17140 
  def validate(self):
17141 
    return
17142 
 
17143 
 
17144 
  def __repr__(self):
17145 
    L = ['%s=%r' % (key, value)
17146 
      for key, value in self.__dict__.iteritems()]
17147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17148 
 
17149 
  def __eq__(self, other):
17150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17151 
 
17152 
  def __ne__(self, other):
17153 
    return not (self == other)
17154 
 
17155 
class getAllBrands_result:
17156 
  """
17157 
  Attributes:
17158 
   - success
17159 
  """
17160 
 
17161 
  thrift_spec = (
17162 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
17163 
  )
17164 
 
17165 
  def __init__(self, success=None,):
17166 
    self.success = success
17167 
 
17168 
  def read(self, iprot):
17169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17171 
      return
17172 
    iprot.readStructBegin()
17173 
    while True:
17174 
      (fname, ftype, fid) = iprot.readFieldBegin()
17175 
      if ftype == TType.STOP:
17176 
        break
17177 
      if fid == 0:
17178 
        if ftype == TType.LIST:
17179 
          self.success = []
9155 kshitij.so 17180 
          (_etype307, _size304) = iprot.readListBegin()
17181 
          for _i308 in xrange(_size304):
17182 
            _elem309 = iprot.readString();
17183 
            self.success.append(_elem309)
5944 mandeep.dh 17184 
          iprot.readListEnd()
17185 
        else:
17186 
          iprot.skip(ftype)
17187 
      else:
17188 
        iprot.skip(ftype)
17189 
      iprot.readFieldEnd()
17190 
    iprot.readStructEnd()
17191 
 
17192 
  def write(self, oprot):
17193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17195 
      return
17196 
    oprot.writeStructBegin('getAllBrands_result')
17197 
    if self.success is not None:
17198 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17199 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 17200 
      for iter310 in self.success:
17201 
        oprot.writeString(iter310)
5944 mandeep.dh 17202 
      oprot.writeListEnd()
17203 
      oprot.writeFieldEnd()
17204 
    oprot.writeFieldStop()
17205 
    oprot.writeStructEnd()
17206 
 
17207 
  def validate(self):
17208 
    return
17209 
 
17210 
 
17211 
  def __repr__(self):
17212 
    L = ['%s=%r' % (key, value)
17213 
      for key, value in self.__dict__.iteritems()]
17214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17215 
 
17216 
  def __eq__(self, other):
17217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17218 
 
17219 
  def __ne__(self, other):
17220 
    return not (self == other)
17221 
 
17222 
class getAllSources_args:
17223 
 
17224 
  thrift_spec = (
17225 
  )
17226 
 
17227 
  def read(self, iprot):
17228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17230 
      return
17231 
    iprot.readStructBegin()
17232 
    while True:
17233 
      (fname, ftype, fid) = iprot.readFieldBegin()
17234 
      if ftype == TType.STOP:
17235 
        break
17236 
      else:
17237 
        iprot.skip(ftype)
17238 
      iprot.readFieldEnd()
17239 
    iprot.readStructEnd()
17240 
 
17241 
  def write(self, oprot):
17242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17244 
      return
17245 
    oprot.writeStructBegin('getAllSources_args')
17246 
    oprot.writeFieldStop()
17247 
    oprot.writeStructEnd()
17248 
 
17249 
  def validate(self):
17250 
    return
17251 
 
17252 
 
17253 
  def __repr__(self):
17254 
    L = ['%s=%r' % (key, value)
17255 
      for key, value in self.__dict__.iteritems()]
17256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17257 
 
17258 
  def __eq__(self, other):
17259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17260 
 
17261 
  def __ne__(self, other):
17262 
    return not (self == other)
17263 
 
17264 
class getAllSources_result:
17265 
  """
17266 
  Attributes:
17267 
   - success
17268 
  """
17269 
 
17270 
  thrift_spec = (
17271 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
17272 
  )
17273 
 
17274 
  def __init__(self, success=None,):
17275 
    self.success = success
17276 
 
17277 
  def read(self, iprot):
17278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17280 
      return
17281 
    iprot.readStructBegin()
17282 
    while True:
17283 
      (fname, ftype, fid) = iprot.readFieldBegin()
17284 
      if ftype == TType.STOP:
17285 
        break
17286 
      if fid == 0:
17287 
        if ftype == TType.LIST:
17288 
          self.success = []
9155 kshitij.so 17289 
          (_etype314, _size311) = iprot.readListBegin()
17290 
          for _i315 in xrange(_size311):
17291 
            _elem316 = Source()
17292 
            _elem316.read(iprot)
17293 
            self.success.append(_elem316)
5944 mandeep.dh 17294 
          iprot.readListEnd()
17295 
        else:
17296 
          iprot.skip(ftype)
17297 
      else:
17298 
        iprot.skip(ftype)
17299 
      iprot.readFieldEnd()
17300 
    iprot.readStructEnd()
17301 
 
17302 
  def write(self, oprot):
17303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17305 
      return
17306 
    oprot.writeStructBegin('getAllSources_result')
17307 
    if self.success is not None:
17308 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17309 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17310 
      for iter317 in self.success:
17311 
        iter317.write(oprot)
5944 mandeep.dh 17312 
      oprot.writeListEnd()
17313 
      oprot.writeFieldEnd()
17314 
    oprot.writeFieldStop()
17315 
    oprot.writeStructEnd()
17316 
 
17317 
  def validate(self):
17318 
    return
17319 
 
17320 
 
17321 
  def __repr__(self):
17322 
    L = ['%s=%r' % (key, value)
17323 
      for key, value in self.__dict__.iteritems()]
17324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17325 
 
17326 
  def __eq__(self, other):
17327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17328 
 
17329 
  def __ne__(self, other):
17330 
    return not (self == other)
17331 
 
17332 
class getItemPricingBySource_args:
17333 
  """
17334 
  Attributes:
17335 
   - itemId
17336 
   - sourceId
17337 
  """
17338 
 
17339 
  thrift_spec = (
17340 
    None, # 0
17341 
    (1, TType.I64, 'itemId', None, None, ), # 1
17342 
    (2, TType.I64, 'sourceId', None, None, ), # 2
17343 
  )
17344 
 
17345 
  def __init__(self, itemId=None, sourceId=None,):
17346 
    self.itemId = itemId
17347 
    self.sourceId = sourceId
17348 
 
17349 
  def read(self, iprot):
17350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17352 
      return
17353 
    iprot.readStructBegin()
17354 
    while True:
17355 
      (fname, ftype, fid) = iprot.readFieldBegin()
17356 
      if ftype == TType.STOP:
17357 
        break
17358 
      if fid == 1:
17359 
        if ftype == TType.I64:
17360 
          self.itemId = iprot.readI64();
17361 
        else:
17362 
          iprot.skip(ftype)
17363 
      elif fid == 2:
17364 
        if ftype == TType.I64:
17365 
          self.sourceId = iprot.readI64();
17366 
        else:
17367 
          iprot.skip(ftype)
17368 
      else:
17369 
        iprot.skip(ftype)
17370 
      iprot.readFieldEnd()
17371 
    iprot.readStructEnd()
17372 
 
17373 
  def write(self, oprot):
17374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17376 
      return
17377 
    oprot.writeStructBegin('getItemPricingBySource_args')
17378 
    if self.itemId is not None:
17379 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17380 
      oprot.writeI64(self.itemId)
17381 
      oprot.writeFieldEnd()
17382 
    if self.sourceId is not None:
17383 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
17384 
      oprot.writeI64(self.sourceId)
17385 
      oprot.writeFieldEnd()
17386 
    oprot.writeFieldStop()
17387 
    oprot.writeStructEnd()
17388 
 
17389 
  def validate(self):
17390 
    return
17391 
 
17392 
 
17393 
  def __repr__(self):
17394 
    L = ['%s=%r' % (key, value)
17395 
      for key, value in self.__dict__.iteritems()]
17396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17397 
 
17398 
  def __eq__(self, other):
17399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17400 
 
17401 
  def __ne__(self, other):
17402 
    return not (self == other)
17403 
 
17404 
class getItemPricingBySource_result:
17405 
  """
17406 
  Attributes:
17407 
   - success
17408 
   - cex
17409 
  """
17410 
 
17411 
  thrift_spec = (
17412 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
17413 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17414 
  )
17415 
 
17416 
  def __init__(self, success=None, cex=None,):
17417 
    self.success = success
17418 
    self.cex = cex
17419 
 
17420 
  def read(self, iprot):
17421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17423 
      return
17424 
    iprot.readStructBegin()
17425 
    while True:
17426 
      (fname, ftype, fid) = iprot.readFieldBegin()
17427 
      if ftype == TType.STOP:
17428 
        break
17429 
      if fid == 0:
17430 
        if ftype == TType.STRUCT:
17431 
          self.success = SourceItemPricing()
17432 
          self.success.read(iprot)
17433 
        else:
17434 
          iprot.skip(ftype)
17435 
      elif fid == 1:
17436 
        if ftype == TType.STRUCT:
17437 
          self.cex = CatalogServiceException()
17438 
          self.cex.read(iprot)
17439 
        else:
17440 
          iprot.skip(ftype)
17441 
      else:
17442 
        iprot.skip(ftype)
17443 
      iprot.readFieldEnd()
17444 
    iprot.readStructEnd()
17445 
 
17446 
  def write(self, oprot):
17447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17449 
      return
17450 
    oprot.writeStructBegin('getItemPricingBySource_result')
17451 
    if self.success is not None:
17452 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17453 
      self.success.write(oprot)
17454 
      oprot.writeFieldEnd()
17455 
    if self.cex is not None:
17456 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17457 
      self.cex.write(oprot)
17458 
      oprot.writeFieldEnd()
17459 
    oprot.writeFieldStop()
17460 
    oprot.writeStructEnd()
17461 
 
17462 
  def validate(self):
17463 
    return
17464 
 
17465 
 
17466 
  def __repr__(self):
17467 
    L = ['%s=%r' % (key, value)
17468 
      for key, value in self.__dict__.iteritems()]
17469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17470 
 
17471 
  def __eq__(self, other):
17472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17473 
 
17474 
  def __ne__(self, other):
17475 
    return not (self == other)
17476 
 
17477 
class addSourceItemPricing_args:
17478 
  """
17479 
  Attributes:
17480 
   - sourceItemPricing
17481 
  """
17482 
 
17483 
  thrift_spec = (
17484 
    None, # 0
17485 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
17486 
  )
17487 
 
17488 
  def __init__(self, sourceItemPricing=None,):
17489 
    self.sourceItemPricing = sourceItemPricing
17490 
 
17491 
  def read(self, iprot):
17492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17494 
      return
17495 
    iprot.readStructBegin()
17496 
    while True:
17497 
      (fname, ftype, fid) = iprot.readFieldBegin()
17498 
      if ftype == TType.STOP:
17499 
        break
17500 
      if fid == 1:
17501 
        if ftype == TType.STRUCT:
17502 
          self.sourceItemPricing = SourceItemPricing()
17503 
          self.sourceItemPricing.read(iprot)
17504 
        else:
17505 
          iprot.skip(ftype)
17506 
      else:
17507 
        iprot.skip(ftype)
17508 
      iprot.readFieldEnd()
17509 
    iprot.readStructEnd()
17510 
 
17511 
  def write(self, oprot):
17512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17514 
      return
17515 
    oprot.writeStructBegin('addSourceItemPricing_args')
17516 
    if self.sourceItemPricing is not None:
17517 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
17518 
      self.sourceItemPricing.write(oprot)
17519 
      oprot.writeFieldEnd()
17520 
    oprot.writeFieldStop()
17521 
    oprot.writeStructEnd()
17522 
 
17523 
  def validate(self):
17524 
    return
17525 
 
17526 
 
17527 
  def __repr__(self):
17528 
    L = ['%s=%r' % (key, value)
17529 
      for key, value in self.__dict__.iteritems()]
17530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17531 
 
17532 
  def __eq__(self, other):
17533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17534 
 
17535 
  def __ne__(self, other):
17536 
    return not (self == other)
17537 
 
17538 
class addSourceItemPricing_result:
17539 
  """
17540 
  Attributes:
17541 
   - cex
17542 
  """
17543 
 
17544 
  thrift_spec = (
17545 
    None, # 0
17546 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17547 
  )
17548 
 
17549 
  def __init__(self, cex=None,):
17550 
    self.cex = cex
17551 
 
17552 
  def read(self, iprot):
17553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17555 
      return
17556 
    iprot.readStructBegin()
17557 
    while True:
17558 
      (fname, ftype, fid) = iprot.readFieldBegin()
17559 
      if ftype == TType.STOP:
17560 
        break
17561 
      if fid == 1:
17562 
        if ftype == TType.STRUCT:
17563 
          self.cex = CatalogServiceException()
17564 
          self.cex.read(iprot)
17565 
        else:
17566 
          iprot.skip(ftype)
17567 
      else:
17568 
        iprot.skip(ftype)
17569 
      iprot.readFieldEnd()
17570 
    iprot.readStructEnd()
17571 
 
17572 
  def write(self, oprot):
17573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17575 
      return
17576 
    oprot.writeStructBegin('addSourceItemPricing_result')
17577 
    if self.cex is not None:
17578 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17579 
      self.cex.write(oprot)
17580 
      oprot.writeFieldEnd()
17581 
    oprot.writeFieldStop()
17582 
    oprot.writeStructEnd()
17583 
 
17584 
  def validate(self):
17585 
    return
17586 
 
17587 
 
17588 
  def __repr__(self):
17589 
    L = ['%s=%r' % (key, value)
17590 
      for key, value in self.__dict__.iteritems()]
17591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17592 
 
17593 
  def __eq__(self, other):
17594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17595 
 
17596 
  def __ne__(self, other):
17597 
    return not (self == other)
17598 
 
17599 
class getAllSourcePricing_args:
17600 
  """
17601 
  Attributes:
17602 
   - itemId
17603 
  """
17604 
 
17605 
  thrift_spec = (
17606 
    None, # 0
17607 
    (1, TType.I64, 'itemId', None, None, ), # 1
17608 
  )
17609 
 
17610 
  def __init__(self, itemId=None,):
17611 
    self.itemId = itemId
17612 
 
17613 
  def read(self, iprot):
17614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17616 
      return
17617 
    iprot.readStructBegin()
17618 
    while True:
17619 
      (fname, ftype, fid) = iprot.readFieldBegin()
17620 
      if ftype == TType.STOP:
17621 
        break
17622 
      if fid == 1:
17623 
        if ftype == TType.I64:
17624 
          self.itemId = iprot.readI64();
17625 
        else:
17626 
          iprot.skip(ftype)
17627 
      else:
17628 
        iprot.skip(ftype)
17629 
      iprot.readFieldEnd()
17630 
    iprot.readStructEnd()
17631 
 
17632 
  def write(self, oprot):
17633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17635 
      return
17636 
    oprot.writeStructBegin('getAllSourcePricing_args')
17637 
    if self.itemId is not None:
17638 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17639 
      oprot.writeI64(self.itemId)
17640 
      oprot.writeFieldEnd()
17641 
    oprot.writeFieldStop()
17642 
    oprot.writeStructEnd()
17643 
 
17644 
  def validate(self):
17645 
    return
17646 
 
17647 
 
17648 
  def __repr__(self):
17649 
    L = ['%s=%r' % (key, value)
17650 
      for key, value in self.__dict__.iteritems()]
17651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17652 
 
17653 
  def __eq__(self, other):
17654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17655 
 
17656 
  def __ne__(self, other):
17657 
    return not (self == other)
17658 
 
17659 
class getAllSourcePricing_result:
17660 
  """
17661 
  Attributes:
17662 
   - success
17663 
   - cex
17664 
  """
17665 
 
17666 
  thrift_spec = (
17667 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
17668 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17669 
  )
17670 
 
17671 
  def __init__(self, success=None, cex=None,):
17672 
    self.success = success
17673 
    self.cex = cex
17674 
 
17675 
  def read(self, iprot):
17676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17678 
      return
17679 
    iprot.readStructBegin()
17680 
    while True:
17681 
      (fname, ftype, fid) = iprot.readFieldBegin()
17682 
      if ftype == TType.STOP:
17683 
        break
17684 
      if fid == 0:
17685 
        if ftype == TType.LIST:
17686 
          self.success = []
9155 kshitij.so 17687 
          (_etype321, _size318) = iprot.readListBegin()
17688 
          for _i322 in xrange(_size318):
17689 
            _elem323 = SourceItemPricing()
17690 
            _elem323.read(iprot)
17691 
            self.success.append(_elem323)
5944 mandeep.dh 17692 
          iprot.readListEnd()
17693 
        else:
17694 
          iprot.skip(ftype)
17695 
      elif fid == 1:
17696 
        if ftype == TType.STRUCT:
17697 
          self.cex = CatalogServiceException()
17698 
          self.cex.read(iprot)
17699 
        else:
17700 
          iprot.skip(ftype)
17701 
      else:
17702 
        iprot.skip(ftype)
17703 
      iprot.readFieldEnd()
17704 
    iprot.readStructEnd()
17705 
 
17706 
  def write(self, oprot):
17707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17709 
      return
17710 
    oprot.writeStructBegin('getAllSourcePricing_result')
17711 
    if self.success is not None:
17712 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17713 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17714 
      for iter324 in self.success:
17715 
        iter324.write(oprot)
5944 mandeep.dh 17716 
      oprot.writeListEnd()
17717 
      oprot.writeFieldEnd()
17718 
    if self.cex is not None:
17719 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17720 
      self.cex.write(oprot)
17721 
      oprot.writeFieldEnd()
17722 
    oprot.writeFieldStop()
17723 
    oprot.writeStructEnd()
17724 
 
17725 
  def validate(self):
17726 
    return
17727 
 
17728 
 
17729 
  def __repr__(self):
17730 
    L = ['%s=%r' % (key, value)
17731 
      for key, value in self.__dict__.iteritems()]
17732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17733 
 
17734 
  def __eq__(self, other):
17735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17736 
 
17737 
  def __ne__(self, other):
17738 
    return not (self == other)
17739 
 
17740 
class getItemForSource_args:
17741 
  """
17742 
  Attributes:
17743 
   - item_id
17744 
   - sourceId
17745 
  """
17746 
 
17747 
  thrift_spec = (
17748 
    None, # 0
17749 
    (1, TType.I64, 'item_id', None, None, ), # 1
17750 
    (2, TType.I64, 'sourceId', None, None, ), # 2
17751 
  )
17752 
 
17753 
  def __init__(self, item_id=None, sourceId=None,):
17754 
    self.item_id = item_id
17755 
    self.sourceId = sourceId
17756 
 
17757 
  def read(self, iprot):
17758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17760 
      return
17761 
    iprot.readStructBegin()
17762 
    while True:
17763 
      (fname, ftype, fid) = iprot.readFieldBegin()
17764 
      if ftype == TType.STOP:
17765 
        break
17766 
      if fid == 1:
17767 
        if ftype == TType.I64:
17768 
          self.item_id = iprot.readI64();
17769 
        else:
17770 
          iprot.skip(ftype)
17771 
      elif fid == 2:
17772 
        if ftype == TType.I64:
17773 
          self.sourceId = 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('getItemForSource_args')
17786 
    if self.item_id is not None:
17787 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
17788 
      oprot.writeI64(self.item_id)
17789 
      oprot.writeFieldEnd()
17790 
    if self.sourceId is not None:
17791 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
17792 
      oprot.writeI64(self.sourceId)
17793 
      oprot.writeFieldEnd()
17794 
    oprot.writeFieldStop()
17795 
    oprot.writeStructEnd()
17796 
 
17797 
  def validate(self):
17798 
    return
17799 
 
17800 
 
17801 
  def __repr__(self):
17802 
    L = ['%s=%r' % (key, value)
17803 
      for key, value in self.__dict__.iteritems()]
17804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17805 
 
17806 
  def __eq__(self, other):
17807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17808 
 
17809 
  def __ne__(self, other):
17810 
    return not (self == other)
17811 
 
17812 
class getItemForSource_result:
17813 
  """
17814 
  Attributes:
17815 
   - success
17816 
   - cex
17817 
  """
17818 
 
17819 
  thrift_spec = (
17820 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
17821 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17822 
  )
17823 
 
17824 
  def __init__(self, success=None, cex=None,):
17825 
    self.success = success
17826 
    self.cex = cex
17827 
 
17828 
  def read(self, iprot):
17829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17831 
      return
17832 
    iprot.readStructBegin()
17833 
    while True:
17834 
      (fname, ftype, fid) = iprot.readFieldBegin()
17835 
      if ftype == TType.STOP:
17836 
        break
17837 
      if fid == 0:
17838 
        if ftype == TType.STRUCT:
17839 
          self.success = Item()
17840 
          self.success.read(iprot)
17841 
        else:
17842 
          iprot.skip(ftype)
17843 
      elif fid == 1:
17844 
        if ftype == TType.STRUCT:
17845 
          self.cex = CatalogServiceException()
17846 
          self.cex.read(iprot)
17847 
        else:
17848 
          iprot.skip(ftype)
17849 
      else:
17850 
        iprot.skip(ftype)
17851 
      iprot.readFieldEnd()
17852 
    iprot.readStructEnd()
17853 
 
17854 
  def write(self, oprot):
17855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17857 
      return
17858 
    oprot.writeStructBegin('getItemForSource_result')
17859 
    if self.success is not None:
17860 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17861 
      self.success.write(oprot)
17862 
      oprot.writeFieldEnd()
17863 
    if self.cex is not None:
17864 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17865 
      self.cex.write(oprot)
17866 
      oprot.writeFieldEnd()
17867 
    oprot.writeFieldStop()
17868 
    oprot.writeStructEnd()
17869 
 
17870 
  def validate(self):
17871 
    return
17872 
 
17873 
 
17874 
  def __repr__(self):
17875 
    L = ['%s=%r' % (key, value)
17876 
      for key, value in self.__dict__.iteritems()]
17877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17878 
 
17879 
  def __eq__(self, other):
17880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17881 
 
17882 
  def __ne__(self, other):
17883 
    return not (self == other)
17884 
 
17885 
class searchItemsInRange_args:
17886 
  """
17887 
  Attributes:
17888 
   - searchTerms
17889 
   - offset
17890 
   - limit
17891 
  """
17892 
 
17893 
  thrift_spec = (
17894 
    None, # 0
17895 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17896 
    (2, TType.I64, 'offset', None, None, ), # 2
17897 
    (3, TType.I64, 'limit', None, None, ), # 3
17898 
  )
17899 
 
17900 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
17901 
    self.searchTerms = searchTerms
17902 
    self.offset = offset
17903 
    self.limit = limit
17904 
 
17905 
  def read(self, iprot):
17906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17908 
      return
17909 
    iprot.readStructBegin()
17910 
    while True:
17911 
      (fname, ftype, fid) = iprot.readFieldBegin()
17912 
      if ftype == TType.STOP:
17913 
        break
17914 
      if fid == 1:
17915 
        if ftype == TType.LIST:
17916 
          self.searchTerms = []
9155 kshitij.so 17917 
          (_etype328, _size325) = iprot.readListBegin()
17918 
          for _i329 in xrange(_size325):
17919 
            _elem330 = iprot.readString();
17920 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 17921 
          iprot.readListEnd()
17922 
        else:
17923 
          iprot.skip(ftype)
17924 
      elif fid == 2:
17925 
        if ftype == TType.I64:
17926 
          self.offset = iprot.readI64();
17927 
        else:
17928 
          iprot.skip(ftype)
17929 
      elif fid == 3:
17930 
        if ftype == TType.I64:
17931 
          self.limit = iprot.readI64();
17932 
        else:
17933 
          iprot.skip(ftype)
17934 
      else:
17935 
        iprot.skip(ftype)
17936 
      iprot.readFieldEnd()
17937 
    iprot.readStructEnd()
17938 
 
17939 
  def write(self, oprot):
17940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17942 
      return
17943 
    oprot.writeStructBegin('searchItemsInRange_args')
17944 
    if self.searchTerms is not None:
17945 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17946 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17947 
      for iter331 in self.searchTerms:
17948 
        oprot.writeString(iter331)
5944 mandeep.dh 17949 
      oprot.writeListEnd()
17950 
      oprot.writeFieldEnd()
17951 
    if self.offset is not None:
17952 
      oprot.writeFieldBegin('offset', TType.I64, 2)
17953 
      oprot.writeI64(self.offset)
17954 
      oprot.writeFieldEnd()
17955 
    if self.limit is not None:
17956 
      oprot.writeFieldBegin('limit', TType.I64, 3)
17957 
      oprot.writeI64(self.limit)
17958 
      oprot.writeFieldEnd()
17959 
    oprot.writeFieldStop()
17960 
    oprot.writeStructEnd()
17961 
 
17962 
  def validate(self):
17963 
    return
17964 
 
17965 
 
17966 
  def __repr__(self):
17967 
    L = ['%s=%r' % (key, value)
17968 
      for key, value in self.__dict__.iteritems()]
17969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17970 
 
17971 
  def __eq__(self, other):
17972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17973 
 
17974 
  def __ne__(self, other):
17975 
    return not (self == other)
17976 
 
17977 
class searchItemsInRange_result:
17978 
  """
17979 
  Attributes:
17980 
   - success
17981 
  """
17982 
 
17983 
  thrift_spec = (
17984 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17985 
  )
17986 
 
17987 
  def __init__(self, success=None,):
17988 
    self.success = success
17989 
 
17990 
  def read(self, iprot):
17991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17993 
      return
17994 
    iprot.readStructBegin()
17995 
    while True:
17996 
      (fname, ftype, fid) = iprot.readFieldBegin()
17997 
      if ftype == TType.STOP:
17998 
        break
17999 
      if fid == 0:
18000 
        if ftype == TType.LIST:
18001 
          self.success = []
9155 kshitij.so 18002 
          (_etype335, _size332) = iprot.readListBegin()
18003 
          for _i336 in xrange(_size332):
18004 
            _elem337 = Item()
18005 
            _elem337.read(iprot)
18006 
            self.success.append(_elem337)
5944 mandeep.dh 18007 
          iprot.readListEnd()
18008 
        else:
18009 
          iprot.skip(ftype)
18010 
      else:
18011 
        iprot.skip(ftype)
18012 
      iprot.readFieldEnd()
18013 
    iprot.readStructEnd()
18014 
 
18015 
  def write(self, oprot):
18016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18018 
      return
18019 
    oprot.writeStructBegin('searchItemsInRange_result')
18020 
    if self.success is not None:
18021 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18022 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18023 
      for iter338 in self.success:
18024 
        iter338.write(oprot)
5944 mandeep.dh 18025 
      oprot.writeListEnd()
18026 
      oprot.writeFieldEnd()
18027 
    oprot.writeFieldStop()
18028 
    oprot.writeStructEnd()
18029 
 
18030 
  def validate(self):
18031 
    return
18032 
 
18033 
 
18034 
  def __repr__(self):
18035 
    L = ['%s=%r' % (key, value)
18036 
      for key, value in self.__dict__.iteritems()]
18037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18038 
 
18039 
  def __eq__(self, other):
18040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18041 
 
18042 
  def __ne__(self, other):
18043 
    return not (self == other)
18044 
 
18045 
class getSearchResultCount_args:
18046 
  """
18047 
  Attributes:
18048 
   - searchTerms
18049 
  """
18050 
 
18051 
  thrift_spec = (
18052 
    None, # 0
18053 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
18054 
  )
18055 
 
18056 
  def __init__(self, searchTerms=None,):
18057 
    self.searchTerms = searchTerms
18058 
 
18059 
  def read(self, iprot):
18060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18062 
      return
18063 
    iprot.readStructBegin()
18064 
    while True:
18065 
      (fname, ftype, fid) = iprot.readFieldBegin()
18066 
      if ftype == TType.STOP:
18067 
        break
18068 
      if fid == 1:
18069 
        if ftype == TType.LIST:
18070 
          self.searchTerms = []
9155 kshitij.so 18071 
          (_etype342, _size339) = iprot.readListBegin()
18072 
          for _i343 in xrange(_size339):
18073 
            _elem344 = iprot.readString();
18074 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 18075 
          iprot.readListEnd()
18076 
        else:
18077 
          iprot.skip(ftype)
18078 
      else:
18079 
        iprot.skip(ftype)
18080 
      iprot.readFieldEnd()
18081 
    iprot.readStructEnd()
18082 
 
18083 
  def write(self, oprot):
18084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18086 
      return
18087 
    oprot.writeStructBegin('getSearchResultCount_args')
18088 
    if self.searchTerms is not None:
18089 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
18090 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 18091 
      for iter345 in self.searchTerms:
18092 
        oprot.writeString(iter345)
5944 mandeep.dh 18093 
      oprot.writeListEnd()
18094 
      oprot.writeFieldEnd()
18095 
    oprot.writeFieldStop()
18096 
    oprot.writeStructEnd()
18097 
 
18098 
  def validate(self):
18099 
    return
18100 
 
18101 
 
18102 
  def __repr__(self):
18103 
    L = ['%s=%r' % (key, value)
18104 
      for key, value in self.__dict__.iteritems()]
18105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18106 
 
18107 
  def __eq__(self, other):
18108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18109 
 
18110 
  def __ne__(self, other):
18111 
    return not (self == other)
18112 
 
18113 
class getSearchResultCount_result:
18114 
  """
18115 
  Attributes:
18116 
   - success
18117 
  """
18118 
 
18119 
  thrift_spec = (
18120 
    (0, TType.I32, 'success', None, None, ), # 0
18121 
  )
18122 
 
18123 
  def __init__(self, success=None,):
18124 
    self.success = success
18125 
 
18126 
  def read(self, iprot):
18127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18129 
      return
18130 
    iprot.readStructBegin()
18131 
    while True:
18132 
      (fname, ftype, fid) = iprot.readFieldBegin()
18133 
      if ftype == TType.STOP:
18134 
        break
18135 
      if fid == 0:
18136 
        if ftype == TType.I32:
18137 
          self.success = iprot.readI32();
18138 
        else:
18139 
          iprot.skip(ftype)
18140 
      else:
18141 
        iprot.skip(ftype)
18142 
      iprot.readFieldEnd()
18143 
    iprot.readStructEnd()
18144 
 
18145 
  def write(self, oprot):
18146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18148 
      return
18149 
    oprot.writeStructBegin('getSearchResultCount_result')
18150 
    if self.success is not None:
18151 
      oprot.writeFieldBegin('success', TType.I32, 0)
18152 
      oprot.writeI32(self.success)
18153 
      oprot.writeFieldEnd()
18154 
    oprot.writeFieldStop()
18155 
    oprot.writeStructEnd()
18156 
 
18157 
  def validate(self):
18158 
    return
18159 
 
18160 
 
18161 
  def __repr__(self):
18162 
    L = ['%s=%r' % (key, value)
18163 
      for key, value in self.__dict__.iteritems()]
18164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18165 
 
18166 
  def __eq__(self, other):
18167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18168 
 
18169 
  def __ne__(self, other):
18170 
    return not (self == other)
18171 
 
18172 
class getProductNotifications_args:
18173 
  """
18174 
  Attributes:
18175 
   - startDateTime
18176 
  """
18177 
 
18178 
  thrift_spec = (
18179 
    None, # 0
18180 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
18181 
  )
18182 
 
18183 
  def __init__(self, startDateTime=None,):
18184 
    self.startDateTime = startDateTime
18185 
 
18186 
  def read(self, iprot):
18187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18189 
      return
18190 
    iprot.readStructBegin()
18191 
    while True:
18192 
      (fname, ftype, fid) = iprot.readFieldBegin()
18193 
      if ftype == TType.STOP:
18194 
        break
18195 
      if fid == 1:
18196 
        if ftype == TType.I64:
18197 
          self.startDateTime = iprot.readI64();
18198 
        else:
18199 
          iprot.skip(ftype)
18200 
      else:
18201 
        iprot.skip(ftype)
18202 
      iprot.readFieldEnd()
18203 
    iprot.readStructEnd()
18204 
 
18205 
  def write(self, oprot):
18206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18208 
      return
18209 
    oprot.writeStructBegin('getProductNotifications_args')
18210 
    if self.startDateTime is not None:
18211 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
18212 
      oprot.writeI64(self.startDateTime)
18213 
      oprot.writeFieldEnd()
18214 
    oprot.writeFieldStop()
18215 
    oprot.writeStructEnd()
18216 
 
18217 
  def validate(self):
18218 
    return
18219 
 
18220 
 
18221 
  def __repr__(self):
18222 
    L = ['%s=%r' % (key, value)
18223 
      for key, value in self.__dict__.iteritems()]
18224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18225 
 
18226 
  def __eq__(self, other):
18227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18228 
 
18229 
  def __ne__(self, other):
18230 
    return not (self == other)
18231 
 
18232 
class getProductNotifications_result:
18233 
  """
18234 
  Attributes:
18235 
   - success
18236 
  """
18237 
 
18238 
  thrift_spec = (
18239 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
18240 
  )
18241 
 
18242 
  def __init__(self, success=None,):
18243 
    self.success = success
18244 
 
18245 
  def read(self, iprot):
18246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18248 
      return
18249 
    iprot.readStructBegin()
18250 
    while True:
18251 
      (fname, ftype, fid) = iprot.readFieldBegin()
18252 
      if ftype == TType.STOP:
18253 
        break
18254 
      if fid == 0:
18255 
        if ftype == TType.LIST:
18256 
          self.success = []
9155 kshitij.so 18257 
          (_etype349, _size346) = iprot.readListBegin()
18258 
          for _i350 in xrange(_size346):
18259 
            _elem351 = ProductNotificationRequest()
18260 
            _elem351.read(iprot)
18261 
            self.success.append(_elem351)
5944 mandeep.dh 18262 
          iprot.readListEnd()
18263 
        else:
18264 
          iprot.skip(ftype)
18265 
      else:
18266 
        iprot.skip(ftype)
18267 
      iprot.readFieldEnd()
18268 
    iprot.readStructEnd()
18269 
 
18270 
  def write(self, oprot):
18271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18273 
      return
18274 
    oprot.writeStructBegin('getProductNotifications_result')
18275 
    if self.success is not None:
18276 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18277 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18278 
      for iter352 in self.success:
18279 
        iter352.write(oprot)
5944 mandeep.dh 18280 
      oprot.writeListEnd()
18281 
      oprot.writeFieldEnd()
18282 
    oprot.writeFieldStop()
18283 
    oprot.writeStructEnd()
18284 
 
18285 
  def validate(self):
18286 
    return
18287 
 
18288 
 
18289 
  def __repr__(self):
18290 
    L = ['%s=%r' % (key, value)
18291 
      for key, value in self.__dict__.iteritems()]
18292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18293 
 
18294 
  def __eq__(self, other):
18295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18296 
 
18297 
  def __ne__(self, other):
18298 
    return not (self == other)
18299 
 
18300 
class getProductNotificationRequestCount_args:
18301 
  """
18302 
  Attributes:
18303 
   - startDateTime
7897 amar.kumar 18304 
   - categoryId
5944 mandeep.dh 18305 
  """
18306 
 
18307 
  thrift_spec = (
18308 
    None, # 0
18309 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 18310 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 18311 
  )
18312 
 
7897 amar.kumar 18313 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 18314 
    self.startDateTime = startDateTime
7897 amar.kumar 18315 
    self.categoryId = categoryId
5944 mandeep.dh 18316 
 
18317 
  def read(self, iprot):
18318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18320 
      return
18321 
    iprot.readStructBegin()
18322 
    while True:
18323 
      (fname, ftype, fid) = iprot.readFieldBegin()
18324 
      if ftype == TType.STOP:
18325 
        break
18326 
      if fid == 1:
18327 
        if ftype == TType.I64:
18328 
          self.startDateTime = iprot.readI64();
18329 
        else:
18330 
          iprot.skip(ftype)
7897 amar.kumar 18331 
      elif fid == 2:
18332 
        if ftype == TType.I64:
18333 
          self.categoryId = iprot.readI64();
18334 
        else:
18335 
          iprot.skip(ftype)
5944 mandeep.dh 18336 
      else:
18337 
        iprot.skip(ftype)
18338 
      iprot.readFieldEnd()
18339 
    iprot.readStructEnd()
18340 
 
18341 
  def write(self, oprot):
18342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18344 
      return
18345 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
18346 
    if self.startDateTime is not None:
18347 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
18348 
      oprot.writeI64(self.startDateTime)
18349 
      oprot.writeFieldEnd()
7897 amar.kumar 18350 
    if self.categoryId is not None:
18351 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
18352 
      oprot.writeI64(self.categoryId)
18353 
      oprot.writeFieldEnd()
5944 mandeep.dh 18354 
    oprot.writeFieldStop()
18355 
    oprot.writeStructEnd()
18356 
 
18357 
  def validate(self):
18358 
    return
18359 
 
18360 
 
18361 
  def __repr__(self):
18362 
    L = ['%s=%r' % (key, value)
18363 
      for key, value in self.__dict__.iteritems()]
18364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18365 
 
18366 
  def __eq__(self, other):
18367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18368 
 
18369 
  def __ne__(self, other):
18370 
    return not (self == other)
18371 
 
18372 
class getProductNotificationRequestCount_result:
18373 
  """
18374 
  Attributes:
18375 
   - success
18376 
  """
18377 
 
18378 
  thrift_spec = (
18379 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
18380 
  )
18381 
 
18382 
  def __init__(self, success=None,):
18383 
    self.success = success
18384 
 
18385 
  def read(self, iprot):
18386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18388 
      return
18389 
    iprot.readStructBegin()
18390 
    while True:
18391 
      (fname, ftype, fid) = iprot.readFieldBegin()
18392 
      if ftype == TType.STOP:
18393 
        break
18394 
      if fid == 0:
18395 
        if ftype == TType.LIST:
18396 
          self.success = []
9155 kshitij.so 18397 
          (_etype356, _size353) = iprot.readListBegin()
18398 
          for _i357 in xrange(_size353):
18399 
            _elem358 = ProductNotificationRequestCount()
18400 
            _elem358.read(iprot)
18401 
            self.success.append(_elem358)
5944 mandeep.dh 18402 
          iprot.readListEnd()
18403 
        else:
18404 
          iprot.skip(ftype)
18405 
      else:
18406 
        iprot.skip(ftype)
18407 
      iprot.readFieldEnd()
18408 
    iprot.readStructEnd()
18409 
 
18410 
  def write(self, oprot):
18411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18413 
      return
18414 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
18415 
    if self.success is not None:
18416 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18417 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18418 
      for iter359 in self.success:
18419 
        iter359.write(oprot)
5944 mandeep.dh 18420 
      oprot.writeListEnd()
18421 
      oprot.writeFieldEnd()
18422 
    oprot.writeFieldStop()
18423 
    oprot.writeStructEnd()
18424 
 
18425 
  def validate(self):
18426 
    return
18427 
 
18428 
 
18429 
  def __repr__(self):
18430 
    L = ['%s=%r' % (key, value)
18431 
      for key, value in self.__dict__.iteritems()]
18432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18433 
 
18434 
  def __eq__(self, other):
18435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18436 
 
18437 
  def __ne__(self, other):
18438 
    return not (self == other)
18439 
 
18440 
class addAuthorizationLog_args:
18441 
  """
18442 
  Attributes:
18443 
   - itemId
18444 
   - username
18445 
   - reason
18446 
  """
18447 
 
18448 
  thrift_spec = (
18449 
    None, # 0
18450 
    (1, TType.I64, 'itemId', None, None, ), # 1
18451 
    (2, TType.STRING, 'username', None, None, ), # 2
18452 
    (3, TType.STRING, 'reason', None, None, ), # 3
18453 
  )
18454 
 
18455 
  def __init__(self, itemId=None, username=None, reason=None,):
18456 
    self.itemId = itemId
18457 
    self.username = username
18458 
    self.reason = reason
18459 
 
18460 
  def read(self, iprot):
18461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18463 
      return
18464 
    iprot.readStructBegin()
18465 
    while True:
18466 
      (fname, ftype, fid) = iprot.readFieldBegin()
18467 
      if ftype == TType.STOP:
18468 
        break
18469 
      if fid == 1:
18470 
        if ftype == TType.I64:
18471 
          self.itemId = iprot.readI64();
18472 
        else:
18473 
          iprot.skip(ftype)
18474 
      elif fid == 2:
18475 
        if ftype == TType.STRING:
18476 
          self.username = iprot.readString();
18477 
        else:
18478 
          iprot.skip(ftype)
18479 
      elif fid == 3:
18480 
        if ftype == TType.STRING:
18481 
          self.reason = iprot.readString();
18482 
        else:
18483 
          iprot.skip(ftype)
18484 
      else:
18485 
        iprot.skip(ftype)
18486 
      iprot.readFieldEnd()
18487 
    iprot.readStructEnd()
18488 
 
18489 
  def write(self, oprot):
18490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18492 
      return
18493 
    oprot.writeStructBegin('addAuthorizationLog_args')
18494 
    if self.itemId is not None:
18495 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18496 
      oprot.writeI64(self.itemId)
18497 
      oprot.writeFieldEnd()
18498 
    if self.username is not None:
18499 
      oprot.writeFieldBegin('username', TType.STRING, 2)
18500 
      oprot.writeString(self.username)
18501 
      oprot.writeFieldEnd()
18502 
    if self.reason is not None:
18503 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18504 
      oprot.writeString(self.reason)
18505 
      oprot.writeFieldEnd()
18506 
    oprot.writeFieldStop()
18507 
    oprot.writeStructEnd()
18508 
 
18509 
  def validate(self):
18510 
    return
18511 
 
18512 
 
18513 
  def __repr__(self):
18514 
    L = ['%s=%r' % (key, value)
18515 
      for key, value in self.__dict__.iteritems()]
18516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18517 
 
18518 
  def __eq__(self, other):
18519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18520 
 
18521 
  def __ne__(self, other):
18522 
    return not (self == other)
18523 
 
18524 
class addAuthorizationLog_result:
18525 
  """
18526 
  Attributes:
18527 
   - success
18528 
   - cex
18529 
  """
18530 
 
18531 
  thrift_spec = (
18532 
    (0, TType.BOOL, 'success', None, None, ), # 0
18533 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18534 
  )
18535 
 
18536 
  def __init__(self, success=None, cex=None,):
18537 
    self.success = success
18538 
    self.cex = cex
18539 
 
18540 
  def read(self, iprot):
18541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18543 
      return
18544 
    iprot.readStructBegin()
18545 
    while True:
18546 
      (fname, ftype, fid) = iprot.readFieldBegin()
18547 
      if ftype == TType.STOP:
18548 
        break
18549 
      if fid == 0:
18550 
        if ftype == TType.BOOL:
18551 
          self.success = iprot.readBool();
18552 
        else:
18553 
          iprot.skip(ftype)
18554 
      elif fid == 1:
18555 
        if ftype == TType.STRUCT:
18556 
          self.cex = CatalogServiceException()
18557 
          self.cex.read(iprot)
18558 
        else:
18559 
          iprot.skip(ftype)
18560 
      else:
18561 
        iprot.skip(ftype)
18562 
      iprot.readFieldEnd()
18563 
    iprot.readStructEnd()
18564 
 
18565 
  def write(self, oprot):
18566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18568 
      return
18569 
    oprot.writeStructBegin('addAuthorizationLog_result')
18570 
    if self.success is not None:
18571 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18572 
      oprot.writeBool(self.success)
18573 
      oprot.writeFieldEnd()
18574 
    if self.cex is not None:
18575 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18576 
      self.cex.write(oprot)
18577 
      oprot.writeFieldEnd()
18578 
    oprot.writeFieldStop()
18579 
    oprot.writeStructEnd()
18580 
 
18581 
  def validate(self):
18582 
    return
18583 
 
18584 
 
18585 
  def __repr__(self):
18586 
    L = ['%s=%r' % (key, value)
18587 
      for key, value in self.__dict__.iteritems()]
18588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18589 
 
18590 
  def __eq__(self, other):
18591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18592 
 
18593 
  def __ne__(self, other):
18594 
    return not (self == other)
18595 
 
18596 
class addupdateVoucherForItem_args:
18597 
  """
18598 
  Attributes:
18599 
   - catalog_item_id
18600 
   - voucherType
18601 
   - voucherAmount
18602 
  """
18603 
 
18604 
  thrift_spec = (
18605 
    None, # 0
18606 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18607 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18608 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
18609 
  )
18610 
 
18611 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
18612 
    self.catalog_item_id = catalog_item_id
18613 
    self.voucherType = voucherType
18614 
    self.voucherAmount = voucherAmount
18615 
 
18616 
  def read(self, iprot):
18617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18619 
      return
18620 
    iprot.readStructBegin()
18621 
    while True:
18622 
      (fname, ftype, fid) = iprot.readFieldBegin()
18623 
      if ftype == TType.STOP:
18624 
        break
18625 
      if fid == 1:
18626 
        if ftype == TType.I64:
18627 
          self.catalog_item_id = iprot.readI64();
18628 
        else:
18629 
          iprot.skip(ftype)
18630 
      elif fid == 2:
18631 
        if ftype == TType.I64:
18632 
          self.voucherType = iprot.readI64();
18633 
        else:
18634 
          iprot.skip(ftype)
18635 
      elif fid == 3:
18636 
        if ftype == TType.I64:
18637 
          self.voucherAmount = iprot.readI64();
18638 
        else:
18639 
          iprot.skip(ftype)
18640 
      else:
18641 
        iprot.skip(ftype)
18642 
      iprot.readFieldEnd()
18643 
    iprot.readStructEnd()
18644 
 
18645 
  def write(self, oprot):
18646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18648 
      return
18649 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
18650 
    if self.catalog_item_id is not None:
18651 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18652 
      oprot.writeI64(self.catalog_item_id)
18653 
      oprot.writeFieldEnd()
18654 
    if self.voucherType is not None:
18655 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18656 
      oprot.writeI64(self.voucherType)
18657 
      oprot.writeFieldEnd()
18658 
    if self.voucherAmount is not None:
18659 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
18660 
      oprot.writeI64(self.voucherAmount)
18661 
      oprot.writeFieldEnd()
18662 
    oprot.writeFieldStop()
18663 
    oprot.writeStructEnd()
18664 
 
18665 
  def validate(self):
18666 
    return
18667 
 
18668 
 
18669 
  def __repr__(self):
18670 
    L = ['%s=%r' % (key, value)
18671 
      for key, value in self.__dict__.iteritems()]
18672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18673 
 
18674 
  def __eq__(self, other):
18675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18676 
 
18677 
  def __ne__(self, other):
18678 
    return not (self == other)
18679 
 
18680 
class addupdateVoucherForItem_result:
18681 
  """
18682 
  Attributes:
18683 
   - success
18684 
   - cex
18685 
  """
18686 
 
18687 
  thrift_spec = (
18688 
    (0, TType.BOOL, 'success', None, None, ), # 0
18689 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18690 
  )
18691 
 
18692 
  def __init__(self, success=None, cex=None,):
18693 
    self.success = success
18694 
    self.cex = cex
18695 
 
18696 
  def read(self, iprot):
18697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18699 
      return
18700 
    iprot.readStructBegin()
18701 
    while True:
18702 
      (fname, ftype, fid) = iprot.readFieldBegin()
18703 
      if ftype == TType.STOP:
18704 
        break
18705 
      if fid == 0:
18706 
        if ftype == TType.BOOL:
18707 
          self.success = iprot.readBool();
18708 
        else:
18709 
          iprot.skip(ftype)
18710 
      elif fid == 1:
18711 
        if ftype == TType.STRUCT:
18712 
          self.cex = CatalogServiceException()
18713 
          self.cex.read(iprot)
18714 
        else:
18715 
          iprot.skip(ftype)
18716 
      else:
18717 
        iprot.skip(ftype)
18718 
      iprot.readFieldEnd()
18719 
    iprot.readStructEnd()
18720 
 
18721 
  def write(self, oprot):
18722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18724 
      return
18725 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
18726 
    if self.success is not None:
18727 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18728 
      oprot.writeBool(self.success)
18729 
      oprot.writeFieldEnd()
18730 
    if self.cex is not None:
18731 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18732 
      self.cex.write(oprot)
18733 
      oprot.writeFieldEnd()
18734 
    oprot.writeFieldStop()
18735 
    oprot.writeStructEnd()
18736 
 
18737 
  def validate(self):
18738 
    return
18739 
 
18740 
 
18741 
  def __repr__(self):
18742 
    L = ['%s=%r' % (key, value)
18743 
      for key, value in self.__dict__.iteritems()]
18744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18745 
 
18746 
  def __eq__(self, other):
18747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18748 
 
18749 
  def __ne__(self, other):
18750 
    return not (self == other)
18751 
 
18752 
class deleteVoucherForItem_args:
18753 
  """
18754 
  Attributes:
18755 
   - catalog_item_id
18756 
   - voucherType
18757 
  """
18758 
 
18759 
  thrift_spec = (
18760 
    None, # 0
18761 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18762 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18763 
  )
18764 
 
18765 
  def __init__(self, catalog_item_id=None, voucherType=None,):
18766 
    self.catalog_item_id = catalog_item_id
18767 
    self.voucherType = voucherType
18768 
 
18769 
  def read(self, iprot):
18770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18772 
      return
18773 
    iprot.readStructBegin()
18774 
    while True:
18775 
      (fname, ftype, fid) = iprot.readFieldBegin()
18776 
      if ftype == TType.STOP:
18777 
        break
18778 
      if fid == 1:
18779 
        if ftype == TType.I64:
18780 
          self.catalog_item_id = iprot.readI64();
18781 
        else:
18782 
          iprot.skip(ftype)
18783 
      elif fid == 2:
18784 
        if ftype == TType.I64:
18785 
          self.voucherType = iprot.readI64();
18786 
        else:
18787 
          iprot.skip(ftype)
18788 
      else:
18789 
        iprot.skip(ftype)
18790 
      iprot.readFieldEnd()
18791 
    iprot.readStructEnd()
18792 
 
18793 
  def write(self, oprot):
18794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18796 
      return
18797 
    oprot.writeStructBegin('deleteVoucherForItem_args')
18798 
    if self.catalog_item_id is not None:
18799 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18800 
      oprot.writeI64(self.catalog_item_id)
18801 
      oprot.writeFieldEnd()
18802 
    if self.voucherType is not None:
18803 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18804 
      oprot.writeI64(self.voucherType)
18805 
      oprot.writeFieldEnd()
18806 
    oprot.writeFieldStop()
18807 
    oprot.writeStructEnd()
18808 
 
18809 
  def validate(self):
18810 
    return
18811 
 
18812 
 
18813 
  def __repr__(self):
18814 
    L = ['%s=%r' % (key, value)
18815 
      for key, value in self.__dict__.iteritems()]
18816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18817 
 
18818 
  def __eq__(self, other):
18819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18820 
 
18821 
  def __ne__(self, other):
18822 
    return not (self == other)
18823 
 
18824 
class deleteVoucherForItem_result:
18825 
  """
18826 
  Attributes:
18827 
   - success
18828 
   - cex
18829 
  """
18830 
 
18831 
  thrift_spec = (
18832 
    (0, TType.BOOL, 'success', None, None, ), # 0
18833 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18834 
  )
18835 
 
18836 
  def __init__(self, success=None, cex=None,):
18837 
    self.success = success
18838 
    self.cex = cex
18839 
 
18840 
  def read(self, iprot):
18841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18843 
      return
18844 
    iprot.readStructBegin()
18845 
    while True:
18846 
      (fname, ftype, fid) = iprot.readFieldBegin()
18847 
      if ftype == TType.STOP:
18848 
        break
18849 
      if fid == 0:
18850 
        if ftype == TType.BOOL:
18851 
          self.success = iprot.readBool();
18852 
        else:
18853 
          iprot.skip(ftype)
18854 
      elif fid == 1:
18855 
        if ftype == TType.STRUCT:
18856 
          self.cex = CatalogServiceException()
18857 
          self.cex.read(iprot)
18858 
        else:
18859 
          iprot.skip(ftype)
18860 
      else:
18861 
        iprot.skip(ftype)
18862 
      iprot.readFieldEnd()
18863 
    iprot.readStructEnd()
18864 
 
18865 
  def write(self, oprot):
18866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18868 
      return
18869 
    oprot.writeStructBegin('deleteVoucherForItem_result')
18870 
    if self.success is not None:
18871 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18872 
      oprot.writeBool(self.success)
18873 
      oprot.writeFieldEnd()
18874 
    if self.cex is not None:
18875 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18876 
      self.cex.write(oprot)
18877 
      oprot.writeFieldEnd()
18878 
    oprot.writeFieldStop()
18879 
    oprot.writeStructEnd()
18880 
 
18881 
  def validate(self):
18882 
    return
18883 
 
18884 
 
18885 
  def __repr__(self):
18886 
    L = ['%s=%r' % (key, value)
18887 
      for key, value in self.__dict__.iteritems()]
18888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18889 
 
18890 
  def __eq__(self, other):
18891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18892 
 
18893 
  def __ne__(self, other):
18894 
    return not (self == other)
18895 
 
18896 
class getVoucherAmount_args:
18897 
  """
18898 
  Attributes:
18899 
   - itemId
18900 
   - voucherType
18901 
  """
18902 
 
18903 
  thrift_spec = (
18904 
    None, # 0
18905 
    (1, TType.I64, 'itemId', None, None, ), # 1
18906 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18907 
  )
18908 
 
18909 
  def __init__(self, itemId=None, voucherType=None,):
18910 
    self.itemId = itemId
18911 
    self.voucherType = voucherType
18912 
 
18913 
  def read(self, iprot):
18914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18916 
      return
18917 
    iprot.readStructBegin()
18918 
    while True:
18919 
      (fname, ftype, fid) = iprot.readFieldBegin()
18920 
      if ftype == TType.STOP:
18921 
        break
18922 
      if fid == 1:
18923 
        if ftype == TType.I64:
18924 
          self.itemId = iprot.readI64();
18925 
        else:
18926 
          iprot.skip(ftype)
18927 
      elif fid == 2:
18928 
        if ftype == TType.I64:
18929 
          self.voucherType = iprot.readI64();
18930 
        else:
18931 
          iprot.skip(ftype)
18932 
      else:
18933 
        iprot.skip(ftype)
18934 
      iprot.readFieldEnd()
18935 
    iprot.readStructEnd()
18936 
 
18937 
  def write(self, oprot):
18938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18940 
      return
18941 
    oprot.writeStructBegin('getVoucherAmount_args')
18942 
    if self.itemId is not None:
18943 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18944 
      oprot.writeI64(self.itemId)
18945 
      oprot.writeFieldEnd()
18946 
    if self.voucherType is not None:
18947 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18948 
      oprot.writeI64(self.voucherType)
18949 
      oprot.writeFieldEnd()
18950 
    oprot.writeFieldStop()
18951 
    oprot.writeStructEnd()
18952 
 
18953 
  def validate(self):
18954 
    return
18955 
 
18956 
 
18957 
  def __repr__(self):
18958 
    L = ['%s=%r' % (key, value)
18959 
      for key, value in self.__dict__.iteritems()]
18960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18961 
 
18962 
  def __eq__(self, other):
18963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18964 
 
18965 
  def __ne__(self, other):
18966 
    return not (self == other)
18967 
 
18968 
class getVoucherAmount_result:
18969 
  """
18970 
  Attributes:
18971 
   - success
18972 
  """
18973 
 
18974 
  thrift_spec = (
18975 
    (0, TType.I64, 'success', None, None, ), # 0
18976 
  )
18977 
 
18978 
  def __init__(self, success=None,):
18979 
    self.success = success
18980 
 
18981 
  def read(self, iprot):
18982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18984 
      return
18985 
    iprot.readStructBegin()
18986 
    while True:
18987 
      (fname, ftype, fid) = iprot.readFieldBegin()
18988 
      if ftype == TType.STOP:
18989 
        break
18990 
      if fid == 0:
18991 
        if ftype == TType.I64:
18992 
          self.success = iprot.readI64();
18993 
        else:
18994 
          iprot.skip(ftype)
18995 
      else:
18996 
        iprot.skip(ftype)
18997 
      iprot.readFieldEnd()
18998 
    iprot.readStructEnd()
18999 
 
19000 
  def write(self, oprot):
19001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19003 
      return
19004 
    oprot.writeStructBegin('getVoucherAmount_result')
19005 
    if self.success is not None:
19006 
      oprot.writeFieldBegin('success', TType.I64, 0)
19007 
      oprot.writeI64(self.success)
19008 
      oprot.writeFieldEnd()
19009 
    oprot.writeFieldStop()
19010 
    oprot.writeStructEnd()
19011 
 
19012 
  def validate(self):
19013 
    return
19014 
 
19015 
 
19016 
  def __repr__(self):
19017 
    L = ['%s=%r' % (key, value)
19018 
      for key, value in self.__dict__.iteritems()]
19019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19020 
 
19021 
  def __eq__(self, other):
19022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19023 
 
19024 
  def __ne__(self, other):
19025 
    return not (self == other)
19026 
 
19027 
class getAllItemVouchers_args:
19028 
  """
19029 
  Attributes:
19030 
   - itemId
19031 
  """
19032 
 
19033 
  thrift_spec = (
19034 
    None, # 0
19035 
    (1, TType.I64, 'itemId', None, None, ), # 1
19036 
  )
19037 
 
19038 
  def __init__(self, itemId=None,):
19039 
    self.itemId = itemId
19040 
 
19041 
  def read(self, iprot):
19042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19044 
      return
19045 
    iprot.readStructBegin()
19046 
    while True:
19047 
      (fname, ftype, fid) = iprot.readFieldBegin()
19048 
      if ftype == TType.STOP:
19049 
        break
19050 
      if fid == 1:
19051 
        if ftype == TType.I64:
19052 
          self.itemId = iprot.readI64();
19053 
        else:
19054 
          iprot.skip(ftype)
19055 
      else:
19056 
        iprot.skip(ftype)
19057 
      iprot.readFieldEnd()
19058 
    iprot.readStructEnd()
19059 
 
19060 
  def write(self, oprot):
19061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19063 
      return
19064 
    oprot.writeStructBegin('getAllItemVouchers_args')
19065 
    if self.itemId is not None:
19066 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19067 
      oprot.writeI64(self.itemId)
19068 
      oprot.writeFieldEnd()
19069 
    oprot.writeFieldStop()
19070 
    oprot.writeStructEnd()
19071 
 
19072 
  def validate(self):
19073 
    return
19074 
 
19075 
 
19076 
  def __repr__(self):
19077 
    L = ['%s=%r' % (key, value)
19078 
      for key, value in self.__dict__.iteritems()]
19079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19080 
 
19081 
  def __eq__(self, other):
19082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19083 
 
19084 
  def __ne__(self, other):
19085 
    return not (self == other)
19086 
 
19087 
class getAllItemVouchers_result:
19088 
  """
19089 
  Attributes:
19090 
   - success
19091 
  """
19092 
 
19093 
  thrift_spec = (
19094 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
19095 
  )
19096 
 
19097 
  def __init__(self, success=None,):
19098 
    self.success = success
19099 
 
19100 
  def read(self, iprot):
19101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19103 
      return
19104 
    iprot.readStructBegin()
19105 
    while True:
19106 
      (fname, ftype, fid) = iprot.readFieldBegin()
19107 
      if ftype == TType.STOP:
19108 
        break
19109 
      if fid == 0:
19110 
        if ftype == TType.LIST:
19111 
          self.success = []
9155 kshitij.so 19112 
          (_etype363, _size360) = iprot.readListBegin()
19113 
          for _i364 in xrange(_size360):
19114 
            _elem365 = VoucherItemMapping()
19115 
            _elem365.read(iprot)
19116 
            self.success.append(_elem365)
5944 mandeep.dh 19117 
          iprot.readListEnd()
19118 
        else:
19119 
          iprot.skip(ftype)
19120 
      else:
19121 
        iprot.skip(ftype)
19122 
      iprot.readFieldEnd()
19123 
    iprot.readStructEnd()
19124 
 
19125 
  def write(self, oprot):
19126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19128 
      return
19129 
    oprot.writeStructBegin('getAllItemVouchers_result')
19130 
    if self.success is not None:
19131 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19132 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19133 
      for iter366 in self.success:
19134 
        iter366.write(oprot)
5944 mandeep.dh 19135 
      oprot.writeListEnd()
19136 
      oprot.writeFieldEnd()
19137 
    oprot.writeFieldStop()
19138 
    oprot.writeStructEnd()
19139 
 
19140 
  def validate(self):
19141 
    return
19142 
 
19143 
 
19144 
  def __repr__(self):
19145 
    L = ['%s=%r' % (key, value)
19146 
      for key, value in self.__dict__.iteritems()]
19147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19148 
 
19149 
  def __eq__(self, other):
19150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19151 
 
19152 
  def __ne__(self, other):
19153 
    return not (self == other)
19154 
 
19155 
class isValidCatalogItemId_args:
19156 
  """
19157 
  Attributes:
19158 
   - catalog_item_id
19159 
  """
19160 
 
19161 
  thrift_spec = (
19162 
    None, # 0
19163 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
19164 
  )
19165 
 
19166 
  def __init__(self, catalog_item_id=None,):
19167 
    self.catalog_item_id = catalog_item_id
19168 
 
19169 
  def read(self, iprot):
19170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19172 
      return
19173 
    iprot.readStructBegin()
19174 
    while True:
19175 
      (fname, ftype, fid) = iprot.readFieldBegin()
19176 
      if ftype == TType.STOP:
19177 
        break
19178 
      if fid == 1:
19179 
        if ftype == TType.I64:
19180 
          self.catalog_item_id = iprot.readI64();
19181 
        else:
19182 
          iprot.skip(ftype)
19183 
      else:
19184 
        iprot.skip(ftype)
19185 
      iprot.readFieldEnd()
19186 
    iprot.readStructEnd()
19187 
 
19188 
  def write(self, oprot):
19189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19191 
      return
19192 
    oprot.writeStructBegin('isValidCatalogItemId_args')
19193 
    if self.catalog_item_id is not None:
19194 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
19195 
      oprot.writeI64(self.catalog_item_id)
19196 
      oprot.writeFieldEnd()
19197 
    oprot.writeFieldStop()
19198 
    oprot.writeStructEnd()
19199 
 
19200 
  def validate(self):
19201 
    return
19202 
 
19203 
 
19204 
  def __repr__(self):
19205 
    L = ['%s=%r' % (key, value)
19206 
      for key, value in self.__dict__.iteritems()]
19207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19208 
 
19209 
  def __eq__(self, other):
19210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19211 
 
19212 
  def __ne__(self, other):
19213 
    return not (self == other)
19214 
 
19215 
class isValidCatalogItemId_result:
19216 
  """
19217 
  Attributes:
19218 
   - success
19219 
  """
19220 
 
19221 
  thrift_spec = (
19222 
    (0, TType.BOOL, 'success', None, None, ), # 0
19223 
  )
19224 
 
19225 
  def __init__(self, success=None,):
19226 
    self.success = success
19227 
 
19228 
  def read(self, iprot):
19229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19231 
      return
19232 
    iprot.readStructBegin()
19233 
    while True:
19234 
      (fname, ftype, fid) = iprot.readFieldBegin()
19235 
      if ftype == TType.STOP:
19236 
        break
19237 
      if fid == 0:
19238 
        if ftype == TType.BOOL:
19239 
          self.success = iprot.readBool();
19240 
        else:
19241 
          iprot.skip(ftype)
19242 
      else:
19243 
        iprot.skip(ftype)
19244 
      iprot.readFieldEnd()
19245 
    iprot.readStructEnd()
19246 
 
19247 
  def write(self, oprot):
19248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19250 
      return
19251 
    oprot.writeStructBegin('isValidCatalogItemId_result')
19252 
    if self.success is not None:
19253 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19254 
      oprot.writeBool(self.success)
19255 
      oprot.writeFieldEnd()
19256 
    oprot.writeFieldStop()
19257 
    oprot.writeStructEnd()
19258 
 
19259 
  def validate(self):
19260 
    return
19261 
 
19262 
 
19263 
  def __repr__(self):
19264 
    L = ['%s=%r' % (key, value)
19265 
      for key, value in self.__dict__.iteritems()]
19266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19267 
 
19268 
  def __eq__(self, other):
19269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19270 
 
19271 
  def __ne__(self, other):
19272 
    return not (self == other)
6039 amit.gupta 19273 
 
19274 
class getVatPercentageForItem_args:
19275 
  """
19276 
  Attributes:
19277 
   - itemId
7330 amit.gupta 19278 
   - stateId
6039 amit.gupta 19279 
   - price
19280 
  """
19281 
 
19282 
  thrift_spec = (
19283 
    None, # 0
19284 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 19285 
    (2, TType.I64, 'stateId', None, None, ), # 2
19286 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 19287 
  )
19288 
 
7330 amit.gupta 19289 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 19290 
    self.itemId = itemId
7330 amit.gupta 19291 
    self.stateId = stateId
6039 amit.gupta 19292 
    self.price = price
19293 
 
19294 
  def read(self, iprot):
19295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19297 
      return
19298 
    iprot.readStructBegin()
19299 
    while True:
19300 
      (fname, ftype, fid) = iprot.readFieldBegin()
19301 
      if ftype == TType.STOP:
19302 
        break
19303 
      if fid == 1:
19304 
        if ftype == TType.I64:
19305 
          self.itemId = iprot.readI64();
19306 
        else:
19307 
          iprot.skip(ftype)
19308 
      elif fid == 2:
7330 amit.gupta 19309 
        if ftype == TType.I64:
19310 
          self.stateId = iprot.readI64();
19311 
        else:
19312 
          iprot.skip(ftype)
19313 
      elif fid == 3:
6039 amit.gupta 19314 
        if ftype == TType.DOUBLE:
19315 
          self.price = iprot.readDouble();
19316 
        else:
19317 
          iprot.skip(ftype)
19318 
      else:
19319 
        iprot.skip(ftype)
19320 
      iprot.readFieldEnd()
19321 
    iprot.readStructEnd()
19322 
 
19323 
  def write(self, oprot):
19324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19326 
      return
19327 
    oprot.writeStructBegin('getVatPercentageForItem_args')
19328 
    if self.itemId is not None:
19329 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19330 
      oprot.writeI64(self.itemId)
19331 
      oprot.writeFieldEnd()
7330 amit.gupta 19332 
    if self.stateId is not None:
19333 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
19334 
      oprot.writeI64(self.stateId)
19335 
      oprot.writeFieldEnd()
6039 amit.gupta 19336 
    if self.price is not None:
7330 amit.gupta 19337 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 19338 
      oprot.writeDouble(self.price)
19339 
      oprot.writeFieldEnd()
19340 
    oprot.writeFieldStop()
19341 
    oprot.writeStructEnd()
19342 
 
19343 
  def validate(self):
19344 
    return
19345 
 
19346 
 
19347 
  def __repr__(self):
19348 
    L = ['%s=%r' % (key, value)
19349 
      for key, value in self.__dict__.iteritems()]
19350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19351 
 
19352 
  def __eq__(self, other):
19353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19354 
 
19355 
  def __ne__(self, other):
19356 
    return not (self == other)
19357 
 
19358 
class getVatPercentageForItem_result:
19359 
  """
19360 
  Attributes:
19361 
   - success
7340 amit.gupta 19362 
   - cex
6039 amit.gupta 19363 
  """
19364 
 
19365 
  thrift_spec = (
19366 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 19367 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 19368 
  )
19369 
 
7340 amit.gupta 19370 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 19371 
    self.success = success
7340 amit.gupta 19372 
    self.cex = cex
6039 amit.gupta 19373 
 
19374 
  def read(self, iprot):
19375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19377 
      return
19378 
    iprot.readStructBegin()
19379 
    while True:
19380 
      (fname, ftype, fid) = iprot.readFieldBegin()
19381 
      if ftype == TType.STOP:
19382 
        break
19383 
      if fid == 0:
19384 
        if ftype == TType.DOUBLE:
19385 
          self.success = iprot.readDouble();
19386 
        else:
19387 
          iprot.skip(ftype)
7340 amit.gupta 19388 
      elif fid == 1:
19389 
        if ftype == TType.STRUCT:
19390 
          self.cex = CatalogServiceException()
19391 
          self.cex.read(iprot)
19392 
        else:
19393 
          iprot.skip(ftype)
6039 amit.gupta 19394 
      else:
19395 
        iprot.skip(ftype)
19396 
      iprot.readFieldEnd()
19397 
    iprot.readStructEnd()
19398 
 
19399 
  def write(self, oprot):
19400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19402 
      return
19403 
    oprot.writeStructBegin('getVatPercentageForItem_result')
19404 
    if self.success is not None:
19405 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
19406 
      oprot.writeDouble(self.success)
19407 
      oprot.writeFieldEnd()
7340 amit.gupta 19408 
    if self.cex is not None:
19409 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19410 
      self.cex.write(oprot)
19411 
      oprot.writeFieldEnd()
6039 amit.gupta 19412 
    oprot.writeFieldStop()
19413 
    oprot.writeStructEnd()
19414 
 
19415 
  def validate(self):
19416 
    return
19417 
 
19418 
 
19419 
  def __repr__(self):
19420 
    L = ['%s=%r' % (key, value)
19421 
      for key, value in self.__dict__.iteritems()]
19422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19423 
 
19424 
  def __eq__(self, other):
19425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19426 
 
19427 
  def __ne__(self, other):
19428 
    return not (self == other)
19429 
 
19430 
class getVatAmountForItem_args:
19431 
  """
19432 
  Attributes:
19433 
   - itemId
19434 
   - price
19435 
  """
19436 
 
19437 
  thrift_spec = (
19438 
    None, # 0
19439 
    (1, TType.I64, 'itemId', None, None, ), # 1
19440 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
19441 
  )
19442 
 
19443 
  def __init__(self, itemId=None, price=None,):
19444 
    self.itemId = itemId
19445 
    self.price = price
19446 
 
19447 
  def read(self, iprot):
19448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19450 
      return
19451 
    iprot.readStructBegin()
19452 
    while True:
19453 
      (fname, ftype, fid) = iprot.readFieldBegin()
19454 
      if ftype == TType.STOP:
19455 
        break
19456 
      if fid == 1:
19457 
        if ftype == TType.I64:
19458 
          self.itemId = iprot.readI64();
19459 
        else:
19460 
          iprot.skip(ftype)
19461 
      elif fid == 2:
19462 
        if ftype == TType.DOUBLE:
19463 
          self.price = iprot.readDouble();
19464 
        else:
19465 
          iprot.skip(ftype)
19466 
      else:
19467 
        iprot.skip(ftype)
19468 
      iprot.readFieldEnd()
19469 
    iprot.readStructEnd()
19470 
 
19471 
  def write(self, oprot):
19472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19474 
      return
19475 
    oprot.writeStructBegin('getVatAmountForItem_args')
19476 
    if self.itemId is not None:
19477 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19478 
      oprot.writeI64(self.itemId)
19479 
      oprot.writeFieldEnd()
19480 
    if self.price is not None:
19481 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
19482 
      oprot.writeDouble(self.price)
19483 
      oprot.writeFieldEnd()
19484 
    oprot.writeFieldStop()
19485 
    oprot.writeStructEnd()
19486 
 
19487 
  def validate(self):
19488 
    return
19489 
 
19490 
 
19491 
  def __repr__(self):
19492 
    L = ['%s=%r' % (key, value)
19493 
      for key, value in self.__dict__.iteritems()]
19494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19495 
 
19496 
  def __eq__(self, other):
19497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19498 
 
19499 
  def __ne__(self, other):
19500 
    return not (self == other)
19501 
 
19502 
class getVatAmountForItem_result:
19503 
  """
19504 
  Attributes:
19505 
   - success
19506 
  """
19507 
 
19508 
  thrift_spec = (
19509 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
19510 
  )
19511 
 
19512 
  def __init__(self, success=None,):
19513 
    self.success = success
19514 
 
19515 
  def read(self, iprot):
19516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19518 
      return
19519 
    iprot.readStructBegin()
19520 
    while True:
19521 
      (fname, ftype, fid) = iprot.readFieldBegin()
19522 
      if ftype == TType.STOP:
19523 
        break
19524 
      if fid == 0:
19525 
        if ftype == TType.DOUBLE:
19526 
          self.success = iprot.readDouble();
19527 
        else:
19528 
          iprot.skip(ftype)
19529 
      else:
19530 
        iprot.skip(ftype)
19531 
      iprot.readFieldEnd()
19532 
    iprot.readStructEnd()
19533 
 
19534 
  def write(self, oprot):
19535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19537 
      return
19538 
    oprot.writeStructBegin('getVatAmountForItem_result')
19539 
    if self.success is not None:
19540 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
19541 
      oprot.writeDouble(self.success)
19542 
      oprot.writeFieldEnd()
19543 
    oprot.writeFieldStop()
19544 
    oprot.writeStructEnd()
19545 
 
19546 
  def validate(self):
19547 
    return
19548 
 
19549 
 
19550 
  def __repr__(self):
19551 
    L = ['%s=%r' % (key, value)
19552 
      for key, value in self.__dict__.iteritems()]
19553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19554 
 
19555 
  def __eq__(self, other):
19556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19557 
 
19558 
  def __ne__(self, other):
19559 
    return not (self == other)
6531 vikram.rag 19560 
 
19561 
class getAllIgnoredInventoryUpdateItemsList_args:
19562 
  """
19563 
  Attributes:
19564 
   - offset
19565 
   - limit
19566 
  """
19567 
 
19568 
  thrift_spec = (
19569 
    None, # 0
19570 
    (1, TType.I32, 'offset', None, None, ), # 1
19571 
    (2, TType.I32, 'limit', None, None, ), # 2
19572 
  )
19573 
 
19574 
  def __init__(self, offset=None, limit=None,):
19575 
    self.offset = offset
19576 
    self.limit = limit
19577 
 
19578 
  def read(self, iprot):
19579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19581 
      return
19582 
    iprot.readStructBegin()
19583 
    while True:
19584 
      (fname, ftype, fid) = iprot.readFieldBegin()
19585 
      if ftype == TType.STOP:
19586 
        break
19587 
      if fid == 1:
19588 
        if ftype == TType.I32:
19589 
          self.offset = iprot.readI32();
19590 
        else:
19591 
          iprot.skip(ftype)
19592 
      elif fid == 2:
19593 
        if ftype == TType.I32:
19594 
          self.limit = iprot.readI32();
19595 
        else:
19596 
          iprot.skip(ftype)
19597 
      else:
19598 
        iprot.skip(ftype)
19599 
      iprot.readFieldEnd()
19600 
    iprot.readStructEnd()
19601 
 
19602 
  def write(self, oprot):
19603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19605 
      return
19606 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
19607 
    if self.offset is not None:
19608 
      oprot.writeFieldBegin('offset', TType.I32, 1)
19609 
      oprot.writeI32(self.offset)
19610 
      oprot.writeFieldEnd()
19611 
    if self.limit is not None:
19612 
      oprot.writeFieldBegin('limit', TType.I32, 2)
19613 
      oprot.writeI32(self.limit)
19614 
      oprot.writeFieldEnd()
19615 
    oprot.writeFieldStop()
19616 
    oprot.writeStructEnd()
19617 
 
19618 
  def validate(self):
19619 
    return
19620 
 
19621 
 
19622 
  def __repr__(self):
19623 
    L = ['%s=%r' % (key, value)
19624 
      for key, value in self.__dict__.iteritems()]
19625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19626 
 
19627 
  def __eq__(self, other):
19628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19629 
 
19630 
  def __ne__(self, other):
19631 
    return not (self == other)
19632 
 
19633 
class getAllIgnoredInventoryUpdateItemsList_result:
19634 
  """
19635 
  Attributes:
19636 
   - success
19637 
  """
19638 
 
19639 
  thrift_spec = (
19640 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19641 
  )
19642 
 
19643 
  def __init__(self, success=None,):
19644 
    self.success = success
19645 
 
19646 
  def read(self, iprot):
19647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19649 
      return
19650 
    iprot.readStructBegin()
19651 
    while True:
19652 
      (fname, ftype, fid) = iprot.readFieldBegin()
19653 
      if ftype == TType.STOP:
19654 
        break
19655 
      if fid == 0:
19656 
        if ftype == TType.LIST:
19657 
          self.success = []
9155 kshitij.so 19658 
          (_etype370, _size367) = iprot.readListBegin()
19659 
          for _i371 in xrange(_size367):
19660 
            _elem372 = Item()
19661 
            _elem372.read(iprot)
19662 
            self.success.append(_elem372)
6531 vikram.rag 19663 
          iprot.readListEnd()
19664 
        else:
19665 
          iprot.skip(ftype)
19666 
      else:
19667 
        iprot.skip(ftype)
19668 
      iprot.readFieldEnd()
19669 
    iprot.readStructEnd()
19670 
 
19671 
  def write(self, oprot):
19672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19674 
      return
19675 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
19676 
    if self.success is not None:
19677 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19678 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19679 
      for iter373 in self.success:
19680 
        iter373.write(oprot)
6531 vikram.rag 19681 
      oprot.writeListEnd()
19682 
      oprot.writeFieldEnd()
19683 
    oprot.writeFieldStop()
19684 
    oprot.writeStructEnd()
19685 
 
19686 
  def validate(self):
19687 
    return
19688 
 
19689 
 
19690 
  def __repr__(self):
19691 
    L = ['%s=%r' % (key, value)
19692 
      for key, value in self.__dict__.iteritems()]
19693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19694 
 
19695 
  def __eq__(self, other):
19696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19697 
 
19698 
  def __ne__(self, other):
19699 
    return not (self == other)
6805 anupam.sin 19700 
 
6821 amar.kumar 19701 
class getAllAliveItems_args:
19702 
 
19703 
  thrift_spec = (
19704 
  )
19705 
 
19706 
  def read(self, iprot):
19707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19709 
      return
19710 
    iprot.readStructBegin()
19711 
    while True:
19712 
      (fname, ftype, fid) = iprot.readFieldBegin()
19713 
      if ftype == TType.STOP:
19714 
        break
19715 
      else:
19716 
        iprot.skip(ftype)
19717 
      iprot.readFieldEnd()
19718 
    iprot.readStructEnd()
19719 
 
19720 
  def write(self, oprot):
19721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19723 
      return
19724 
    oprot.writeStructBegin('getAllAliveItems_args')
19725 
    oprot.writeFieldStop()
19726 
    oprot.writeStructEnd()
19727 
 
19728 
  def validate(self):
19729 
    return
19730 
 
19731 
 
19732 
  def __repr__(self):
19733 
    L = ['%s=%r' % (key, value)
19734 
      for key, value in self.__dict__.iteritems()]
19735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19736 
 
19737 
  def __eq__(self, other):
19738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19739 
 
19740 
  def __ne__(self, other):
19741 
    return not (self == other)
19742 
 
19743 
class getAllAliveItems_result:
19744 
  """
19745 
  Attributes:
19746 
   - success
19747 
  """
19748 
 
19749 
  thrift_spec = (
19750 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19751 
  )
19752 
 
19753 
  def __init__(self, success=None,):
19754 
    self.success = success
19755 
 
19756 
  def read(self, iprot):
19757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19759 
      return
19760 
    iprot.readStructBegin()
19761 
    while True:
19762 
      (fname, ftype, fid) = iprot.readFieldBegin()
19763 
      if ftype == TType.STOP:
19764 
        break
19765 
      if fid == 0:
19766 
        if ftype == TType.LIST:
19767 
          self.success = []
9155 kshitij.so 19768 
          (_etype377, _size374) = iprot.readListBegin()
19769 
          for _i378 in xrange(_size374):
19770 
            _elem379 = Item()
19771 
            _elem379.read(iprot)
19772 
            self.success.append(_elem379)
6821 amar.kumar 19773 
          iprot.readListEnd()
19774 
        else:
19775 
          iprot.skip(ftype)
19776 
      else:
19777 
        iprot.skip(ftype)
19778 
      iprot.readFieldEnd()
19779 
    iprot.readStructEnd()
19780 
 
19781 
  def write(self, oprot):
19782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19784 
      return
19785 
    oprot.writeStructBegin('getAllAliveItems_result')
19786 
    if self.success is not None:
19787 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19788 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19789 
      for iter380 in self.success:
19790 
        iter380.write(oprot)
6821 amar.kumar 19791 
      oprot.writeListEnd()
19792 
      oprot.writeFieldEnd()
19793 
    oprot.writeFieldStop()
19794 
    oprot.writeStructEnd()
19795 
 
19796 
  def validate(self):
19797 
    return
19798 
 
19799 
 
19800 
  def __repr__(self):
19801 
    L = ['%s=%r' % (key, value)
19802 
      for key, value in self.__dict__.iteritems()]
19803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19804 
 
19805 
  def __eq__(self, other):
19806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19807 
 
19808 
  def __ne__(self, other):
19809 
    return not (self == other)
19810 
 
6805 anupam.sin 19811 
class getInsuranceAmount_args:
19812 
  """
19813 
  Attributes:
19814 
   - itemId
6921 anupam.sin 19815 
   - price
6805 anupam.sin 19816 
   - insurerId
19817 
   - quantity
19818 
  """
19819 
 
19820 
  thrift_spec = (
19821 
    None, # 0
19822 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 19823 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
19824 
    (3, TType.I64, 'insurerId', None, None, ), # 3
19825 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 19826 
  )
19827 
 
6921 anupam.sin 19828 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 19829 
    self.itemId = itemId
6921 anupam.sin 19830 
    self.price = price
6805 anupam.sin 19831 
    self.insurerId = insurerId
19832 
    self.quantity = quantity
19833 
 
19834 
  def read(self, iprot):
19835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19837 
      return
19838 
    iprot.readStructBegin()
19839 
    while True:
19840 
      (fname, ftype, fid) = iprot.readFieldBegin()
19841 
      if ftype == TType.STOP:
19842 
        break
19843 
      if fid == 1:
19844 
        if ftype == TType.I64:
19845 
          self.itemId = iprot.readI64();
19846 
        else:
19847 
          iprot.skip(ftype)
19848 
      elif fid == 2:
6921 anupam.sin 19849 
        if ftype == TType.DOUBLE:
19850 
          self.price = iprot.readDouble();
19851 
        else:
19852 
          iprot.skip(ftype)
19853 
      elif fid == 3:
6805 anupam.sin 19854 
        if ftype == TType.I64:
19855 
          self.insurerId = iprot.readI64();
19856 
        else:
19857 
          iprot.skip(ftype)
6921 anupam.sin 19858 
      elif fid == 4:
6805 anupam.sin 19859 
        if ftype == TType.I64:
19860 
          self.quantity = iprot.readI64();
19861 
        else:
19862 
          iprot.skip(ftype)
19863 
      else:
19864 
        iprot.skip(ftype)
19865 
      iprot.readFieldEnd()
19866 
    iprot.readStructEnd()
19867 
 
19868 
  def write(self, oprot):
19869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19871 
      return
19872 
    oprot.writeStructBegin('getInsuranceAmount_args')
19873 
    if self.itemId is not None:
19874 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19875 
      oprot.writeI64(self.itemId)
19876 
      oprot.writeFieldEnd()
6921 anupam.sin 19877 
    if self.price is not None:
19878 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
19879 
      oprot.writeDouble(self.price)
19880 
      oprot.writeFieldEnd()
6805 anupam.sin 19881 
    if self.insurerId is not None:
6921 anupam.sin 19882 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 19883 
      oprot.writeI64(self.insurerId)
19884 
      oprot.writeFieldEnd()
19885 
    if self.quantity is not None:
6921 anupam.sin 19886 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 19887 
      oprot.writeI64(self.quantity)
19888 
      oprot.writeFieldEnd()
19889 
    oprot.writeFieldStop()
19890 
    oprot.writeStructEnd()
19891 
 
19892 
  def validate(self):
19893 
    return
19894 
 
19895 
 
19896 
  def __repr__(self):
19897 
    L = ['%s=%r' % (key, value)
19898 
      for key, value in self.__dict__.iteritems()]
19899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19900 
 
19901 
  def __eq__(self, other):
19902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19903 
 
19904 
  def __ne__(self, other):
19905 
    return not (self == other)
19906 
 
19907 
class getInsuranceAmount_result:
19908 
  """
19909 
  Attributes:
19910 
   - success
19911 
  """
19912 
 
19913 
  thrift_spec = (
19914 
    (0, TType.I64, 'success', None, None, ), # 0
19915 
  )
19916 
 
19917 
  def __init__(self, success=None,):
19918 
    self.success = success
19919 
 
19920 
  def read(self, iprot):
19921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19923 
      return
19924 
    iprot.readStructBegin()
19925 
    while True:
19926 
      (fname, ftype, fid) = iprot.readFieldBegin()
19927 
      if ftype == TType.STOP:
19928 
        break
19929 
      if fid == 0:
19930 
        if ftype == TType.I64:
19931 
          self.success = iprot.readI64();
19932 
        else:
19933 
          iprot.skip(ftype)
19934 
      else:
19935 
        iprot.skip(ftype)
19936 
      iprot.readFieldEnd()
19937 
    iprot.readStructEnd()
19938 
 
19939 
  def write(self, oprot):
19940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19942 
      return
19943 
    oprot.writeStructBegin('getInsuranceAmount_result')
19944 
    if self.success is not None:
19945 
      oprot.writeFieldBegin('success', TType.I64, 0)
19946 
      oprot.writeI64(self.success)
19947 
      oprot.writeFieldEnd()
19948 
    oprot.writeFieldStop()
19949 
    oprot.writeStructEnd()
19950 
 
19951 
  def validate(self):
19952 
    return
19953 
 
19954 
 
19955 
  def __repr__(self):
19956 
    L = ['%s=%r' % (key, value)
19957 
      for key, value in self.__dict__.iteritems()]
19958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19959 
 
19960 
  def __eq__(self, other):
19961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19962 
 
19963 
  def __ne__(self, other):
19964 
    return not (self == other)
19965 
 
19966 
class getInsurer_args:
19967 
  """
19968 
  Attributes:
19969 
   - insurerId
19970 
  """
19971 
 
19972 
  thrift_spec = (
19973 
    None, # 0
19974 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19975 
  )
19976 
 
19977 
  def __init__(self, insurerId=None,):
19978 
    self.insurerId = insurerId
19979 
 
19980 
  def read(self, iprot):
19981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19983 
      return
19984 
    iprot.readStructBegin()
19985 
    while True:
19986 
      (fname, ftype, fid) = iprot.readFieldBegin()
19987 
      if ftype == TType.STOP:
19988 
        break
19989 
      if fid == 1:
19990 
        if ftype == TType.I64:
19991 
          self.insurerId = iprot.readI64();
19992 
        else:
19993 
          iprot.skip(ftype)
19994 
      else:
19995 
        iprot.skip(ftype)
19996 
      iprot.readFieldEnd()
19997 
    iprot.readStructEnd()
19998 
 
19999 
  def write(self, oprot):
20000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20002 
      return
20003 
    oprot.writeStructBegin('getInsurer_args')
20004 
    if self.insurerId is not None:
20005 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
20006 
      oprot.writeI64(self.insurerId)
20007 
      oprot.writeFieldEnd()
20008 
    oprot.writeFieldStop()
20009 
    oprot.writeStructEnd()
20010 
 
20011 
  def validate(self):
20012 
    return
20013 
 
20014 
 
20015 
  def __repr__(self):
20016 
    L = ['%s=%r' % (key, value)
20017 
      for key, value in self.__dict__.iteritems()]
20018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20019 
 
20020 
  def __eq__(self, other):
20021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20022 
 
20023 
  def __ne__(self, other):
20024 
    return not (self == other)
20025 
 
20026 
class getInsurer_result:
20027 
  """
20028 
  Attributes:
20029 
   - success
20030 
  """
20031 
 
20032 
  thrift_spec = (
20033 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
20034 
  )
20035 
 
20036 
  def __init__(self, success=None,):
20037 
    self.success = success
20038 
 
20039 
  def read(self, iprot):
20040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20042 
      return
20043 
    iprot.readStructBegin()
20044 
    while True:
20045 
      (fname, ftype, fid) = iprot.readFieldBegin()
20046 
      if ftype == TType.STOP:
20047 
        break
20048 
      if fid == 0:
20049 
        if ftype == TType.STRUCT:
20050 
          self.success = Insurer()
20051 
          self.success.read(iprot)
20052 
        else:
20053 
          iprot.skip(ftype)
20054 
      else:
20055 
        iprot.skip(ftype)
20056 
      iprot.readFieldEnd()
20057 
    iprot.readStructEnd()
20058 
 
20059 
  def write(self, oprot):
20060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20062 
      return
20063 
    oprot.writeStructBegin('getInsurer_result')
20064 
    if self.success is not None:
20065 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20066 
      self.success.write(oprot)
20067 
      oprot.writeFieldEnd()
20068 
    oprot.writeFieldStop()
20069 
    oprot.writeStructEnd()
20070 
 
20071 
  def validate(self):
20072 
    return
20073 
 
20074 
 
20075 
  def __repr__(self):
20076 
    L = ['%s=%r' % (key, value)
20077 
      for key, value in self.__dict__.iteritems()]
20078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20079 
 
20080 
  def __eq__(self, other):
20081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20082 
 
20083 
  def __ne__(self, other):
20084 
    return not (self == other)
6838 vikram.rag 20085 
 
20086 
class getAllInsurers_args:
20087 
 
20088 
  thrift_spec = (
20089 
  )
20090 
 
20091 
  def read(self, iprot):
20092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20094 
      return
20095 
    iprot.readStructBegin()
20096 
    while True:
20097 
      (fname, ftype, fid) = iprot.readFieldBegin()
20098 
      if ftype == TType.STOP:
20099 
        break
20100 
      else:
20101 
        iprot.skip(ftype)
20102 
      iprot.readFieldEnd()
20103 
    iprot.readStructEnd()
20104 
 
20105 
  def write(self, oprot):
20106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20108 
      return
20109 
    oprot.writeStructBegin('getAllInsurers_args')
20110 
    oprot.writeFieldStop()
20111 
    oprot.writeStructEnd()
20112 
 
20113 
  def validate(self):
20114 
    return
20115 
 
20116 
 
20117 
  def __repr__(self):
20118 
    L = ['%s=%r' % (key, value)
20119 
      for key, value in self.__dict__.iteritems()]
20120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20121 
 
20122 
  def __eq__(self, other):
20123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20124 
 
20125 
  def __ne__(self, other):
20126 
    return not (self == other)
20127 
 
20128 
class getAllInsurers_result:
20129 
  """
20130 
  Attributes:
20131 
   - success
20132 
  """
20133 
 
20134 
  thrift_spec = (
20135 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
20136 
  )
20137 
 
20138 
  def __init__(self, success=None,):
20139 
    self.success = success
20140 
 
20141 
  def read(self, iprot):
20142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20144 
      return
20145 
    iprot.readStructBegin()
20146 
    while True:
20147 
      (fname, ftype, fid) = iprot.readFieldBegin()
20148 
      if ftype == TType.STOP:
20149 
        break
20150 
      if fid == 0:
20151 
        if ftype == TType.LIST:
20152 
          self.success = []
9155 kshitij.so 20153 
          (_etype384, _size381) = iprot.readListBegin()
20154 
          for _i385 in xrange(_size381):
20155 
            _elem386 = Insurer()
20156 
            _elem386.read(iprot)
20157 
            self.success.append(_elem386)
6838 vikram.rag 20158 
          iprot.readListEnd()
20159 
        else:
20160 
          iprot.skip(ftype)
20161 
      else:
20162 
        iprot.skip(ftype)
20163 
      iprot.readFieldEnd()
20164 
    iprot.readStructEnd()
20165 
 
20166 
  def write(self, oprot):
20167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20169 
      return
20170 
    oprot.writeStructBegin('getAllInsurers_result')
20171 
    if self.success is not None:
20172 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20173 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20174 
      for iter387 in self.success:
20175 
        iter387.write(oprot)
6838 vikram.rag 20176 
      oprot.writeListEnd()
20177 
      oprot.writeFieldEnd()
20178 
    oprot.writeFieldStop()
20179 
    oprot.writeStructEnd()
20180 
 
20181 
  def validate(self):
20182 
    return
20183 
 
20184 
 
20185 
  def __repr__(self):
20186 
    L = ['%s=%r' % (key, value)
20187 
      for key, value in self.__dict__.iteritems()]
20188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20189 
 
20190 
  def __eq__(self, other):
20191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20192 
 
20193 
  def __ne__(self, other):
20194 
    return not (self == other)
6962 rajveer 20195 
 
20196 
class updateInsuranceDeclaredAmount_args:
20197 
  """
20198 
  Attributes:
20199 
   - insurerId
20200 
   - amount
20201 
  """
20202 
 
20203 
  thrift_spec = (
20204 
    None, # 0
20205 
    (1, TType.I64, 'insurerId', None, None, ), # 1
20206 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
20207 
  )
20208 
 
20209 
  def __init__(self, insurerId=None, amount=None,):
20210 
    self.insurerId = insurerId
20211 
    self.amount = amount
20212 
 
20213 
  def read(self, iprot):
20214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20216 
      return
20217 
    iprot.readStructBegin()
20218 
    while True:
20219 
      (fname, ftype, fid) = iprot.readFieldBegin()
20220 
      if ftype == TType.STOP:
20221 
        break
20222 
      if fid == 1:
20223 
        if ftype == TType.I64:
20224 
          self.insurerId = iprot.readI64();
20225 
        else:
20226 
          iprot.skip(ftype)
20227 
      elif fid == 2:
20228 
        if ftype == TType.DOUBLE:
20229 
          self.amount = iprot.readDouble();
20230 
        else:
20231 
          iprot.skip(ftype)
20232 
      else:
20233 
        iprot.skip(ftype)
20234 
      iprot.readFieldEnd()
20235 
    iprot.readStructEnd()
20236 
 
20237 
  def write(self, oprot):
20238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20240 
      return
20241 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
20242 
    if self.insurerId is not None:
20243 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
20244 
      oprot.writeI64(self.insurerId)
20245 
      oprot.writeFieldEnd()
20246 
    if self.amount is not None:
20247 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
20248 
      oprot.writeDouble(self.amount)
20249 
      oprot.writeFieldEnd()
20250 
    oprot.writeFieldStop()
20251 
    oprot.writeStructEnd()
20252 
 
20253 
  def validate(self):
20254 
    return
20255 
 
20256 
 
20257 
  def __repr__(self):
20258 
    L = ['%s=%r' % (key, value)
20259 
      for key, value in self.__dict__.iteritems()]
20260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20261 
 
20262 
  def __eq__(self, other):
20263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20264 
 
20265 
  def __ne__(self, other):
20266 
    return not (self == other)
20267 
 
20268 
class updateInsuranceDeclaredAmount_result:
20269 
 
20270 
  thrift_spec = (
20271 
  )
20272 
 
20273 
  def read(self, iprot):
20274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20276 
      return
20277 
    iprot.readStructBegin()
20278 
    while True:
20279 
      (fname, ftype, fid) = iprot.readFieldBegin()
20280 
      if ftype == TType.STOP:
20281 
        break
20282 
      else:
20283 
        iprot.skip(ftype)
20284 
      iprot.readFieldEnd()
20285 
    iprot.readStructEnd()
20286 
 
20287 
  def write(self, oprot):
20288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20290 
      return
20291 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
20292 
    oprot.writeFieldStop()
20293 
    oprot.writeStructEnd()
20294 
 
20295 
  def validate(self):
20296 
    return
20297 
 
20298 
 
20299 
  def __repr__(self):
20300 
    L = ['%s=%r' % (key, value)
20301 
      for key, value in self.__dict__.iteritems()]
20302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20303 
 
20304 
  def __eq__(self, other):
20305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20306 
 
20307 
  def __ne__(self, other):
20308 
    return not (self == other)
7190 amar.kumar 20309 
 
20310 
class getFreebieForItem_args:
20311 
  """
20312 
  Attributes:
20313 
   - itemId
20314 
  """
20315 
 
20316 
  thrift_spec = (
20317 
    None, # 0
20318 
    (1, TType.I64, 'itemId', None, None, ), # 1
20319 
  )
20320 
 
20321 
  def __init__(self, itemId=None,):
20322 
    self.itemId = itemId
20323 
 
20324 
  def read(self, iprot):
20325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20327 
      return
20328 
    iprot.readStructBegin()
20329 
    while True:
20330 
      (fname, ftype, fid) = iprot.readFieldBegin()
20331 
      if ftype == TType.STOP:
20332 
        break
20333 
      if fid == 1:
20334 
        if ftype == TType.I64:
20335 
          self.itemId = iprot.readI64();
20336 
        else:
20337 
          iprot.skip(ftype)
20338 
      else:
20339 
        iprot.skip(ftype)
20340 
      iprot.readFieldEnd()
20341 
    iprot.readStructEnd()
20342 
 
20343 
  def write(self, oprot):
20344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20346 
      return
20347 
    oprot.writeStructBegin('getFreebieForItem_args')
20348 
    if self.itemId is not None:
20349 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20350 
      oprot.writeI64(self.itemId)
20351 
      oprot.writeFieldEnd()
20352 
    oprot.writeFieldStop()
20353 
    oprot.writeStructEnd()
20354 
 
20355 
  def validate(self):
20356 
    return
20357 
 
20358 
 
20359 
  def __repr__(self):
20360 
    L = ['%s=%r' % (key, value)
20361 
      for key, value in self.__dict__.iteritems()]
20362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20363 
 
20364 
  def __eq__(self, other):
20365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20366 
 
20367 
  def __ne__(self, other):
20368 
    return not (self == other)
20369 
 
20370 
class getFreebieForItem_result:
20371 
  """
20372 
  Attributes:
20373 
   - success
20374 
  """
20375 
 
20376 
  thrift_spec = (
20377 
    (0, TType.I64, 'success', None, None, ), # 0
20378 
  )
20379 
 
20380 
  def __init__(self, success=None,):
20381 
    self.success = success
20382 
 
20383 
  def read(self, iprot):
20384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20386 
      return
20387 
    iprot.readStructBegin()
20388 
    while True:
20389 
      (fname, ftype, fid) = iprot.readFieldBegin()
20390 
      if ftype == TType.STOP:
20391 
        break
20392 
      if fid == 0:
20393 
        if ftype == TType.I64:
20394 
          self.success = iprot.readI64();
20395 
        else:
20396 
          iprot.skip(ftype)
20397 
      else:
20398 
        iprot.skip(ftype)
20399 
      iprot.readFieldEnd()
20400 
    iprot.readStructEnd()
20401 
 
20402 
  def write(self, oprot):
20403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20405 
      return
20406 
    oprot.writeStructBegin('getFreebieForItem_result')
20407 
    if self.success is not None:
20408 
      oprot.writeFieldBegin('success', TType.I64, 0)
20409 
      oprot.writeI64(self.success)
20410 
      oprot.writeFieldEnd()
20411 
    oprot.writeFieldStop()
20412 
    oprot.writeStructEnd()
20413 
 
20414 
  def validate(self):
20415 
    return
20416 
 
20417 
 
20418 
  def __repr__(self):
20419 
    L = ['%s=%r' % (key, value)
20420 
      for key, value in self.__dict__.iteritems()]
20421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20422 
 
20423 
  def __eq__(self, other):
20424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20425 
 
20426 
  def __ne__(self, other):
20427 
    return not (self == other)
20428 
 
20429 
class addOrUpdateFreebieForItem_args:
20430 
  """
20431 
  Attributes:
20432 
   - freebieItem
20433 
  """
20434 
 
20435 
  thrift_spec = (
20436 
    None, # 0
20437 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
20438 
  )
20439 
 
20440 
  def __init__(self, freebieItem=None,):
20441 
    self.freebieItem = freebieItem
20442 
 
20443 
  def read(self, iprot):
20444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20446 
      return
20447 
    iprot.readStructBegin()
20448 
    while True:
20449 
      (fname, ftype, fid) = iprot.readFieldBegin()
20450 
      if ftype == TType.STOP:
20451 
        break
20452 
      if fid == 1:
20453 
        if ftype == TType.STRUCT:
20454 
          self.freebieItem = FreebieItem()
20455 
          self.freebieItem.read(iprot)
20456 
        else:
20457 
          iprot.skip(ftype)
20458 
      else:
20459 
        iprot.skip(ftype)
20460 
      iprot.readFieldEnd()
20461 
    iprot.readStructEnd()
20462 
 
20463 
  def write(self, oprot):
20464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20466 
      return
20467 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
20468 
    if self.freebieItem is not None:
20469 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
20470 
      self.freebieItem.write(oprot)
20471 
      oprot.writeFieldEnd()
20472 
    oprot.writeFieldStop()
20473 
    oprot.writeStructEnd()
20474 
 
20475 
  def validate(self):
20476 
    return
20477 
 
20478 
 
20479 
  def __repr__(self):
20480 
    L = ['%s=%r' % (key, value)
20481 
      for key, value in self.__dict__.iteritems()]
20482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20483 
 
20484 
  def __eq__(self, other):
20485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20486 
 
20487 
  def __ne__(self, other):
20488 
    return not (self == other)
20489 
 
20490 
class addOrUpdateFreebieForItem_result:
20491 
 
20492 
  thrift_spec = (
20493 
  )
20494 
 
20495 
  def read(self, iprot):
20496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20498 
      return
20499 
    iprot.readStructBegin()
20500 
    while True:
20501 
      (fname, ftype, fid) = iprot.readFieldBegin()
20502 
      if ftype == TType.STOP:
20503 
        break
20504 
      else:
20505 
        iprot.skip(ftype)
20506 
      iprot.readFieldEnd()
20507 
    iprot.readStructEnd()
20508 
 
20509 
  def write(self, oprot):
20510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20512 
      return
20513 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
20514 
    oprot.writeFieldStop()
20515 
    oprot.writeStructEnd()
20516 
 
20517 
  def validate(self):
20518 
    return
20519 
 
20520 
 
20521 
  def __repr__(self):
20522 
    L = ['%s=%r' % (key, value)
20523 
      for key, value in self.__dict__.iteritems()]
20524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20525 
 
20526 
  def __eq__(self, other):
20527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20528 
 
20529 
  def __ne__(self, other):
20530 
    return not (self == other)
7256 rajveer 20531 
 
7272 amit.gupta 20532 
class addOrUpdateBrandInfo_args:
20533 
  """
20534 
  Attributes:
20535 
   - brandInfo
20536 
  """
20537 
 
20538 
  thrift_spec = (
20539 
    None, # 0
20540 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
20541 
  )
20542 
 
20543 
  def __init__(self, brandInfo=None,):
20544 
    self.brandInfo = brandInfo
20545 
 
20546 
  def read(self, iprot):
20547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20549 
      return
20550 
    iprot.readStructBegin()
20551 
    while True:
20552 
      (fname, ftype, fid) = iprot.readFieldBegin()
20553 
      if ftype == TType.STOP:
20554 
        break
20555 
      if fid == 1:
20556 
        if ftype == TType.STRUCT:
20557 
          self.brandInfo = BrandInfo()
20558 
          self.brandInfo.read(iprot)
20559 
        else:
20560 
          iprot.skip(ftype)
20561 
      else:
20562 
        iprot.skip(ftype)
20563 
      iprot.readFieldEnd()
20564 
    iprot.readStructEnd()
20565 
 
20566 
  def write(self, oprot):
20567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20569 
      return
20570 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
20571 
    if self.brandInfo is not None:
20572 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
20573 
      self.brandInfo.write(oprot)
20574 
      oprot.writeFieldEnd()
20575 
    oprot.writeFieldStop()
20576 
    oprot.writeStructEnd()
20577 
 
20578 
  def validate(self):
20579 
    return
20580 
 
20581 
 
20582 
  def __repr__(self):
20583 
    L = ['%s=%r' % (key, value)
20584 
      for key, value in self.__dict__.iteritems()]
20585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20586 
 
20587 
  def __eq__(self, other):
20588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20589 
 
20590 
  def __ne__(self, other):
20591 
    return not (self == other)
20592 
 
20593 
class addOrUpdateBrandInfo_result:
20594 
 
20595 
  thrift_spec = (
20596 
  )
20597 
 
20598 
  def read(self, iprot):
20599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20601 
      return
20602 
    iprot.readStructBegin()
20603 
    while True:
20604 
      (fname, ftype, fid) = iprot.readFieldBegin()
20605 
      if ftype == TType.STOP:
20606 
        break
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('addOrUpdateBrandInfo_result')
20617 
    oprot.writeFieldStop()
20618 
    oprot.writeStructEnd()
20619 
 
20620 
  def validate(self):
20621 
    return
20622 
 
20623 
 
20624 
  def __repr__(self):
20625 
    L = ['%s=%r' % (key, value)
20626 
      for key, value in self.__dict__.iteritems()]
20627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20628 
 
20629 
  def __eq__(self, other):
20630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20631 
 
20632 
  def __ne__(self, other):
20633 
    return not (self == other)
20634 
 
20635 
class getBrandInfo_args:
20636 
 
20637 
  thrift_spec = (
20638 
  )
20639 
 
20640 
  def read(self, iprot):
20641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20643 
      return
20644 
    iprot.readStructBegin()
20645 
    while True:
20646 
      (fname, ftype, fid) = iprot.readFieldBegin()
20647 
      if ftype == TType.STOP:
20648 
        break
20649 
      else:
20650 
        iprot.skip(ftype)
20651 
      iprot.readFieldEnd()
20652 
    iprot.readStructEnd()
20653 
 
20654 
  def write(self, oprot):
20655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20657 
      return
20658 
    oprot.writeStructBegin('getBrandInfo_args')
20659 
    oprot.writeFieldStop()
20660 
    oprot.writeStructEnd()
20661 
 
20662 
  def validate(self):
20663 
    return
20664 
 
20665 
 
20666 
  def __repr__(self):
20667 
    L = ['%s=%r' % (key, value)
20668 
      for key, value in self.__dict__.iteritems()]
20669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20670 
 
20671 
  def __eq__(self, other):
20672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20673 
 
20674 
  def __ne__(self, other):
20675 
    return not (self == other)
20676 
 
20677 
class getBrandInfo_result:
20678 
  """
20679 
  Attributes:
20680 
   - success
20681 
  """
20682 
 
20683 
  thrift_spec = (
20684 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
20685 
  )
20686 
 
20687 
  def __init__(self, success=None,):
20688 
    self.success = success
20689 
 
20690 
  def read(self, iprot):
20691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20693 
      return
20694 
    iprot.readStructBegin()
20695 
    while True:
20696 
      (fname, ftype, fid) = iprot.readFieldBegin()
20697 
      if ftype == TType.STOP:
20698 
        break
20699 
      if fid == 0:
20700 
        if ftype == TType.MAP:
20701 
          self.success = {}
9155 kshitij.so 20702 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
20703 
          for _i392 in xrange(_size388):
20704 
            _key393 = iprot.readString();
20705 
            _val394 = BrandInfo()
20706 
            _val394.read(iprot)
20707 
            self.success[_key393] = _val394
7272 amit.gupta 20708 
          iprot.readMapEnd()
20709 
        else:
20710 
          iprot.skip(ftype)
20711 
      else:
20712 
        iprot.skip(ftype)
20713 
      iprot.readFieldEnd()
20714 
    iprot.readStructEnd()
20715 
 
20716 
  def write(self, oprot):
20717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20719 
      return
20720 
    oprot.writeStructBegin('getBrandInfo_result')
20721 
    if self.success is not None:
20722 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20723 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 20724 
      for kiter395,viter396 in self.success.items():
20725 
        oprot.writeString(kiter395)
20726 
        viter396.write(oprot)
7272 amit.gupta 20727 
      oprot.writeMapEnd()
20728 
      oprot.writeFieldEnd()
20729 
    oprot.writeFieldStop()
20730 
    oprot.writeStructEnd()
20731 
 
20732 
  def validate(self):
20733 
    return
20734 
 
20735 
 
20736 
  def __repr__(self):
20737 
    L = ['%s=%r' % (key, value)
20738 
      for key, value in self.__dict__.iteritems()]
20739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20740 
 
20741 
  def __eq__(self, other):
20742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20743 
 
20744 
  def __ne__(self, other):
20745 
    return not (self == other)
20746 
 
7256 rajveer 20747 
class getStorePricing_args:
20748 
  """
20749 
  Attributes:
20750 
   - itemId
20751 
  """
20752 
 
20753 
  thrift_spec = (
20754 
    None, # 0
20755 
    (1, TType.I64, 'itemId', None, None, ), # 1
20756 
  )
20757 
 
20758 
  def __init__(self, itemId=None,):
20759 
    self.itemId = itemId
20760 
 
20761 
  def read(self, iprot):
20762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20764 
      return
20765 
    iprot.readStructBegin()
20766 
    while True:
20767 
      (fname, ftype, fid) = iprot.readFieldBegin()
20768 
      if ftype == TType.STOP:
20769 
        break
20770 
      if fid == 1:
20771 
        if ftype == TType.I64:
20772 
          self.itemId = iprot.readI64();
20773 
        else:
20774 
          iprot.skip(ftype)
20775 
      else:
20776 
        iprot.skip(ftype)
20777 
      iprot.readFieldEnd()
20778 
    iprot.readStructEnd()
20779 
 
20780 
  def write(self, oprot):
20781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20783 
      return
20784 
    oprot.writeStructBegin('getStorePricing_args')
20785 
    if self.itemId is not None:
20786 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20787 
      oprot.writeI64(self.itemId)
20788 
      oprot.writeFieldEnd()
20789 
    oprot.writeFieldStop()
20790 
    oprot.writeStructEnd()
20791 
 
20792 
  def validate(self):
20793 
    return
20794 
 
20795 
 
20796 
  def __repr__(self):
20797 
    L = ['%s=%r' % (key, value)
20798 
      for key, value in self.__dict__.iteritems()]
20799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20800 
 
20801 
  def __eq__(self, other):
20802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20803 
 
20804 
  def __ne__(self, other):
20805 
    return not (self == other)
20806 
 
20807 
class getStorePricing_result:
20808 
  """
20809 
  Attributes:
20810 
   - success
20811 
  """
20812 
 
20813 
  thrift_spec = (
20814 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
20815 
  )
20816 
 
20817 
  def __init__(self, success=None,):
20818 
    self.success = success
20819 
 
20820 
  def read(self, iprot):
20821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20823 
      return
20824 
    iprot.readStructBegin()
20825 
    while True:
20826 
      (fname, ftype, fid) = iprot.readFieldBegin()
20827 
      if ftype == TType.STOP:
20828 
        break
20829 
      if fid == 0:
20830 
        if ftype == TType.STRUCT:
20831 
          self.success = StorePricing()
20832 
          self.success.read(iprot)
20833 
        else:
20834 
          iprot.skip(ftype)
20835 
      else:
20836 
        iprot.skip(ftype)
20837 
      iprot.readFieldEnd()
20838 
    iprot.readStructEnd()
20839 
 
20840 
  def write(self, oprot):
20841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20843 
      return
20844 
    oprot.writeStructBegin('getStorePricing_result')
20845 
    if self.success is not None:
20846 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20847 
      self.success.write(oprot)
20848 
      oprot.writeFieldEnd()
20849 
    oprot.writeFieldStop()
20850 
    oprot.writeStructEnd()
20851 
 
20852 
  def validate(self):
20853 
    return
20854 
 
20855 
 
20856 
  def __repr__(self):
20857 
    L = ['%s=%r' % (key, value)
20858 
      for key, value in self.__dict__.iteritems()]
20859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20860 
 
20861 
  def __eq__(self, other):
20862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20863 
 
20864 
  def __ne__(self, other):
20865 
    return not (self == other)
7265 rajveer 20866 
 
7306 rajveer 20867 
class getStorePricings_args:
20868 
  """
20869 
  Attributes:
20870 
   - itemIds
20871 
  """
20872 
 
20873 
  thrift_spec = (
20874 
    None, # 0
20875 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20876 
  )
20877 
 
20878 
  def __init__(self, itemIds=None,):
20879 
    self.itemIds = itemIds
20880 
 
20881 
  def read(self, iprot):
20882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20884 
      return
20885 
    iprot.readStructBegin()
20886 
    while True:
20887 
      (fname, ftype, fid) = iprot.readFieldBegin()
20888 
      if ftype == TType.STOP:
20889 
        break
20890 
      if fid == 1:
20891 
        if ftype == TType.LIST:
20892 
          self.itemIds = []
9155 kshitij.so 20893 
          (_etype400, _size397) = iprot.readListBegin()
20894 
          for _i401 in xrange(_size397):
20895 
            _elem402 = iprot.readI64();
20896 
            self.itemIds.append(_elem402)
7306 rajveer 20897 
          iprot.readListEnd()
20898 
        else:
20899 
          iprot.skip(ftype)
20900 
      else:
20901 
        iprot.skip(ftype)
20902 
      iprot.readFieldEnd()
20903 
    iprot.readStructEnd()
20904 
 
20905 
  def write(self, oprot):
20906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20908 
      return
20909 
    oprot.writeStructBegin('getStorePricings_args')
20910 
    if self.itemIds is not None:
20911 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20912 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 20913 
      for iter403 in self.itemIds:
20914 
        oprot.writeI64(iter403)
7306 rajveer 20915 
      oprot.writeListEnd()
20916 
      oprot.writeFieldEnd()
20917 
    oprot.writeFieldStop()
20918 
    oprot.writeStructEnd()
20919 
 
20920 
  def validate(self):
20921 
    return
20922 
 
20923 
 
20924 
  def __repr__(self):
20925 
    L = ['%s=%r' % (key, value)
20926 
      for key, value in self.__dict__.iteritems()]
20927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20928 
 
20929 
  def __eq__(self, other):
20930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20931 
 
20932 
  def __ne__(self, other):
20933 
    return not (self == other)
20934 
 
20935 
class getStorePricings_result:
20936 
  """
20937 
  Attributes:
20938 
   - success
20939 
  """
20940 
 
20941 
  thrift_spec = (
20942 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
20943 
  )
20944 
 
20945 
  def __init__(self, success=None,):
20946 
    self.success = success
20947 
 
20948 
  def read(self, iprot):
20949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20951 
      return
20952 
    iprot.readStructBegin()
20953 
    while True:
20954 
      (fname, ftype, fid) = iprot.readFieldBegin()
20955 
      if ftype == TType.STOP:
20956 
        break
20957 
      if fid == 0:
20958 
        if ftype == TType.LIST:
20959 
          self.success = []
9155 kshitij.so 20960 
          (_etype407, _size404) = iprot.readListBegin()
20961 
          for _i408 in xrange(_size404):
20962 
            _elem409 = StorePricing()
20963 
            _elem409.read(iprot)
20964 
            self.success.append(_elem409)
7306 rajveer 20965 
          iprot.readListEnd()
20966 
        else:
20967 
          iprot.skip(ftype)
20968 
      else:
20969 
        iprot.skip(ftype)
20970 
      iprot.readFieldEnd()
20971 
    iprot.readStructEnd()
20972 
 
20973 
  def write(self, oprot):
20974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20976 
      return
20977 
    oprot.writeStructBegin('getStorePricings_result')
20978 
    if self.success is not None:
20979 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20980 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20981 
      for iter410 in self.success:
20982 
        iter410.write(oprot)
7306 rajveer 20983 
      oprot.writeListEnd()
20984 
      oprot.writeFieldEnd()
20985 
    oprot.writeFieldStop()
20986 
    oprot.writeStructEnd()
20987 
 
20988 
  def validate(self):
20989 
    return
20990 
 
20991 
 
20992 
  def __repr__(self):
20993 
    L = ['%s=%r' % (key, value)
20994 
      for key, value in self.__dict__.iteritems()]
20995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20996 
 
20997 
  def __eq__(self, other):
20998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20999 
 
21000 
  def __ne__(self, other):
21001 
    return not (self == other)
21002 
 
7265 rajveer 21003 
class updateStorePricing_args:
21004 
  """
21005 
  Attributes:
21006 
   - sp
7382 rajveer 21007 
   - allColors
7265 rajveer 21008 
  """
21009 
 
21010 
  thrift_spec = (
21011 
    None, # 0
21012 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 21013 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 21014 
  )
21015 
 
7382 rajveer 21016 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 21017 
    self.sp = sp
7382 rajveer 21018 
    self.allColors = allColors
7265 rajveer 21019 
 
21020 
  def read(self, iprot):
21021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21023 
      return
21024 
    iprot.readStructBegin()
21025 
    while True:
21026 
      (fname, ftype, fid) = iprot.readFieldBegin()
21027 
      if ftype == TType.STOP:
21028 
        break
21029 
      if fid == 1:
21030 
        if ftype == TType.STRUCT:
21031 
          self.sp = StorePricing()
21032 
          self.sp.read(iprot)
21033 
        else:
21034 
          iprot.skip(ftype)
7382 rajveer 21035 
      elif fid == 2:
21036 
        if ftype == TType.BOOL:
21037 
          self.allColors = iprot.readBool();
21038 
        else:
21039 
          iprot.skip(ftype)
7265 rajveer 21040 
      else:
21041 
        iprot.skip(ftype)
21042 
      iprot.readFieldEnd()
21043 
    iprot.readStructEnd()
21044 
 
21045 
  def write(self, oprot):
21046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21048 
      return
21049 
    oprot.writeStructBegin('updateStorePricing_args')
21050 
    if self.sp is not None:
21051 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
21052 
      self.sp.write(oprot)
21053 
      oprot.writeFieldEnd()
7382 rajveer 21054 
    if self.allColors is not None:
21055 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
21056 
      oprot.writeBool(self.allColors)
21057 
      oprot.writeFieldEnd()
7265 rajveer 21058 
    oprot.writeFieldStop()
21059 
    oprot.writeStructEnd()
21060 
 
21061 
  def validate(self):
21062 
    return
21063 
 
21064 
 
21065 
  def __repr__(self):
21066 
    L = ['%s=%r' % (key, value)
21067 
      for key, value in self.__dict__.iteritems()]
21068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21069 
 
21070 
  def __eq__(self, other):
21071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21072 
 
21073 
  def __ne__(self, other):
21074 
    return not (self == other)
21075 
 
21076 
class updateStorePricing_result:
21077 
 
21078 
  thrift_spec = (
21079 
  )
21080 
 
21081 
  def read(self, iprot):
21082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21084 
      return
21085 
    iprot.readStructBegin()
21086 
    while True:
21087 
      (fname, ftype, fid) = iprot.readFieldBegin()
21088 
      if ftype == TType.STOP:
21089 
        break
21090 
      else:
21091 
        iprot.skip(ftype)
21092 
      iprot.readFieldEnd()
21093 
    iprot.readStructEnd()
21094 
 
21095 
  def write(self, oprot):
21096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21098 
      return
21099 
    oprot.writeStructBegin('updateStorePricing_result')
21100 
    oprot.writeFieldStop()
21101 
    oprot.writeStructEnd()
21102 
 
21103 
  def validate(self):
21104 
    return
21105 
 
21106 
 
21107 
  def __repr__(self):
21108 
    L = ['%s=%r' % (key, value)
21109 
      for key, value in self.__dict__.iteritems()]
21110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21111 
 
21112 
  def __eq__(self, other):
21113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21114 
 
21115 
  def __ne__(self, other):
21116 
    return not (self == other)
7281 kshitij.so 21117 
 
21118 
class getAllAmazonListedItems_args:
21119 
 
21120 
  thrift_spec = (
21121 
  )
21122 
 
21123 
  def read(self, iprot):
21124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21126 
      return
21127 
    iprot.readStructBegin()
21128 
    while True:
21129 
      (fname, ftype, fid) = iprot.readFieldBegin()
21130 
      if ftype == TType.STOP:
21131 
        break
21132 
      else:
21133 
        iprot.skip(ftype)
21134 
      iprot.readFieldEnd()
21135 
    iprot.readStructEnd()
21136 
 
21137 
  def write(self, oprot):
21138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21140 
      return
21141 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
21142 
    oprot.writeFieldStop()
21143 
    oprot.writeStructEnd()
21144 
 
21145 
  def validate(self):
21146 
    return
21147 
 
21148 
 
21149 
  def __repr__(self):
21150 
    L = ['%s=%r' % (key, value)
21151 
      for key, value in self.__dict__.iteritems()]
21152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21153 
 
21154 
  def __eq__(self, other):
21155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21156 
 
21157 
  def __ne__(self, other):
21158 
    return not (self == other)
21159 
 
21160 
class getAllAmazonListedItems_result:
21161 
  """
21162 
  Attributes:
21163 
   - success
21164 
  """
21165 
 
21166 
  thrift_spec = (
21167 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21168 
  )
21169 
 
21170 
  def __init__(self, success=None,):
21171 
    self.success = success
21172 
 
21173 
  def read(self, iprot):
21174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21176 
      return
21177 
    iprot.readStructBegin()
21178 
    while True:
21179 
      (fname, ftype, fid) = iprot.readFieldBegin()
21180 
      if ftype == TType.STOP:
21181 
        break
21182 
      if fid == 0:
21183 
        if ftype == TType.LIST:
21184 
          self.success = []
9155 kshitij.so 21185 
          (_etype414, _size411) = iprot.readListBegin()
21186 
          for _i415 in xrange(_size411):
21187 
            _elem416 = Amazonlisted()
21188 
            _elem416.read(iprot)
21189 
            self.success.append(_elem416)
7281 kshitij.so 21190 
          iprot.readListEnd()
21191 
        else:
21192 
          iprot.skip(ftype)
21193 
      else:
21194 
        iprot.skip(ftype)
21195 
      iprot.readFieldEnd()
21196 
    iprot.readStructEnd()
21197 
 
21198 
  def write(self, oprot):
21199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21201 
      return
21202 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
21203 
    if self.success is not None:
21204 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21205 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21206 
      for iter417 in self.success:
21207 
        iter417.write(oprot)
7281 kshitij.so 21208 
      oprot.writeListEnd()
21209 
      oprot.writeFieldEnd()
21210 
    oprot.writeFieldStop()
21211 
    oprot.writeStructEnd()
21212 
 
21213 
  def validate(self):
21214 
    return
21215 
 
21216 
 
21217 
  def __repr__(self):
21218 
    L = ['%s=%r' % (key, value)
21219 
      for key, value in self.__dict__.iteritems()]
21220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21221 
 
21222 
  def __eq__(self, other):
21223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21224 
 
21225 
  def __ne__(self, other):
21226 
    return not (self == other)
21227 
 
8619 kshitij.so 21228 
class searchAmazonItems_args:
21229 
  """
21230 
  Attributes:
21231 
   - searchTerm
21232 
   - offset
21233 
   - limit
21234 
  """
21235 
 
21236 
  thrift_spec = (
21237 
    None, # 0
21238 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
21239 
    (2, TType.I64, 'offset', None, None, ), # 2
21240 
    (3, TType.I64, 'limit', None, None, ), # 3
21241 
  )
21242 
 
21243 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
21244 
    self.searchTerm = searchTerm
21245 
    self.offset = offset
21246 
    self.limit = limit
21247 
 
21248 
  def read(self, iprot):
21249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21251 
      return
21252 
    iprot.readStructBegin()
21253 
    while True:
21254 
      (fname, ftype, fid) = iprot.readFieldBegin()
21255 
      if ftype == TType.STOP:
21256 
        break
21257 
      if fid == 1:
21258 
        if ftype == TType.LIST:
21259 
          self.searchTerm = []
9155 kshitij.so 21260 
          (_etype421, _size418) = iprot.readListBegin()
21261 
          for _i422 in xrange(_size418):
21262 
            _elem423 = iprot.readString();
21263 
            self.searchTerm.append(_elem423)
8619 kshitij.so 21264 
          iprot.readListEnd()
21265 
        else:
21266 
          iprot.skip(ftype)
21267 
      elif fid == 2:
21268 
        if ftype == TType.I64:
21269 
          self.offset = iprot.readI64();
21270 
        else:
21271 
          iprot.skip(ftype)
21272 
      elif fid == 3:
21273 
        if ftype == TType.I64:
21274 
          self.limit = iprot.readI64();
21275 
        else:
21276 
          iprot.skip(ftype)
21277 
      else:
21278 
        iprot.skip(ftype)
21279 
      iprot.readFieldEnd()
21280 
    iprot.readStructEnd()
21281 
 
21282 
  def write(self, oprot):
21283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21285 
      return
21286 
    oprot.writeStructBegin('searchAmazonItems_args')
21287 
    if self.searchTerm is not None:
21288 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
21289 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 21290 
      for iter424 in self.searchTerm:
21291 
        oprot.writeString(iter424)
8619 kshitij.so 21292 
      oprot.writeListEnd()
21293 
      oprot.writeFieldEnd()
21294 
    if self.offset is not None:
21295 
      oprot.writeFieldBegin('offset', TType.I64, 2)
21296 
      oprot.writeI64(self.offset)
21297 
      oprot.writeFieldEnd()
21298 
    if self.limit is not None:
21299 
      oprot.writeFieldBegin('limit', TType.I64, 3)
21300 
      oprot.writeI64(self.limit)
21301 
      oprot.writeFieldEnd()
21302 
    oprot.writeFieldStop()
21303 
    oprot.writeStructEnd()
21304 
 
21305 
  def validate(self):
21306 
    return
21307 
 
21308 
 
21309 
  def __repr__(self):
21310 
    L = ['%s=%r' % (key, value)
21311 
      for key, value in self.__dict__.iteritems()]
21312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21313 
 
21314 
  def __eq__(self, other):
21315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21316 
 
21317 
  def __ne__(self, other):
21318 
    return not (self == other)
21319 
 
21320 
class searchAmazonItems_result:
21321 
  """
21322 
  Attributes:
21323 
   - success
21324 
  """
21325 
 
21326 
  thrift_spec = (
21327 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21328 
  )
21329 
 
21330 
  def __init__(self, success=None,):
21331 
    self.success = success
21332 
 
21333 
  def read(self, iprot):
21334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21336 
      return
21337 
    iprot.readStructBegin()
21338 
    while True:
21339 
      (fname, ftype, fid) = iprot.readFieldBegin()
21340 
      if ftype == TType.STOP:
21341 
        break
21342 
      if fid == 0:
21343 
        if ftype == TType.LIST:
21344 
          self.success = []
9155 kshitij.so 21345 
          (_etype428, _size425) = iprot.readListBegin()
21346 
          for _i429 in xrange(_size425):
21347 
            _elem430 = Amazonlisted()
21348 
            _elem430.read(iprot)
21349 
            self.success.append(_elem430)
8619 kshitij.so 21350 
          iprot.readListEnd()
21351 
        else:
21352 
          iprot.skip(ftype)
21353 
      else:
21354 
        iprot.skip(ftype)
21355 
      iprot.readFieldEnd()
21356 
    iprot.readStructEnd()
21357 
 
21358 
  def write(self, oprot):
21359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21361 
      return
21362 
    oprot.writeStructBegin('searchAmazonItems_result')
21363 
    if self.success is not None:
21364 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21365 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21366 
      for iter431 in self.success:
21367 
        iter431.write(oprot)
8619 kshitij.so 21368 
      oprot.writeListEnd()
21369 
      oprot.writeFieldEnd()
21370 
    oprot.writeFieldStop()
21371 
    oprot.writeStructEnd()
21372 
 
21373 
  def validate(self):
21374 
    return
21375 
 
21376 
 
21377 
  def __repr__(self):
21378 
    L = ['%s=%r' % (key, value)
21379 
      for key, value in self.__dict__.iteritems()]
21380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21381 
 
21382 
  def __eq__(self, other):
21383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21384 
 
21385 
  def __ne__(self, other):
21386 
    return not (self == other)
21387 
 
21388 
class getAmazonSearchResultCount_args:
21389 
  """
21390 
  Attributes:
21391 
   - searchTerm
21392 
  """
21393 
 
21394 
  thrift_spec = (
21395 
    None, # 0
21396 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
21397 
  )
21398 
 
21399 
  def __init__(self, searchTerm=None,):
21400 
    self.searchTerm = searchTerm
21401 
 
21402 
  def read(self, iprot):
21403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21405 
      return
21406 
    iprot.readStructBegin()
21407 
    while True:
21408 
      (fname, ftype, fid) = iprot.readFieldBegin()
21409 
      if ftype == TType.STOP:
21410 
        break
21411 
      if fid == 1:
21412 
        if ftype == TType.LIST:
21413 
          self.searchTerm = []
9155 kshitij.so 21414 
          (_etype435, _size432) = iprot.readListBegin()
21415 
          for _i436 in xrange(_size432):
21416 
            _elem437 = iprot.readString();
21417 
            self.searchTerm.append(_elem437)
8619 kshitij.so 21418 
          iprot.readListEnd()
21419 
        else:
21420 
          iprot.skip(ftype)
21421 
      else:
21422 
        iprot.skip(ftype)
21423 
      iprot.readFieldEnd()
21424 
    iprot.readStructEnd()
21425 
 
21426 
  def write(self, oprot):
21427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21429 
      return
21430 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
21431 
    if self.searchTerm is not None:
21432 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
21433 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 21434 
      for iter438 in self.searchTerm:
21435 
        oprot.writeString(iter438)
8619 kshitij.so 21436 
      oprot.writeListEnd()
21437 
      oprot.writeFieldEnd()
21438 
    oprot.writeFieldStop()
21439 
    oprot.writeStructEnd()
21440 
 
21441 
  def validate(self):
21442 
    return
21443 
 
21444 
 
21445 
  def __repr__(self):
21446 
    L = ['%s=%r' % (key, value)
21447 
      for key, value in self.__dict__.iteritems()]
21448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21449 
 
21450 
  def __eq__(self, other):
21451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21452 
 
21453 
  def __ne__(self, other):
21454 
    return not (self == other)
21455 
 
21456 
class getAmazonSearchResultCount_result:
21457 
  """
21458 
  Attributes:
21459 
   - success
21460 
  """
21461 
 
21462 
  thrift_spec = (
21463 
    (0, TType.I64, 'success', None, None, ), # 0
21464 
  )
21465 
 
21466 
  def __init__(self, success=None,):
21467 
    self.success = success
21468 
 
21469 
  def read(self, iprot):
21470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21472 
      return
21473 
    iprot.readStructBegin()
21474 
    while True:
21475 
      (fname, ftype, fid) = iprot.readFieldBegin()
21476 
      if ftype == TType.STOP:
21477 
        break
21478 
      if fid == 0:
21479 
        if ftype == TType.I64:
21480 
          self.success = iprot.readI64();
21481 
        else:
21482 
          iprot.skip(ftype)
21483 
      else:
21484 
        iprot.skip(ftype)
21485 
      iprot.readFieldEnd()
21486 
    iprot.readStructEnd()
21487 
 
21488 
  def write(self, oprot):
21489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21491 
      return
21492 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
21493 
    if self.success is not None:
21494 
      oprot.writeFieldBegin('success', TType.I64, 0)
21495 
      oprot.writeI64(self.success)
21496 
      oprot.writeFieldEnd()
21497 
    oprot.writeFieldStop()
21498 
    oprot.writeStructEnd()
21499 
 
21500 
  def validate(self):
21501 
    return
21502 
 
21503 
 
21504 
  def __repr__(self):
21505 
    L = ['%s=%r' % (key, value)
21506 
      for key, value in self.__dict__.iteritems()]
21507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21508 
 
21509 
  def __eq__(self, other):
21510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21511 
 
21512 
  def __ne__(self, other):
21513 
    return not (self == other)
21514 
 
21515 
class getCountForAmazonlistedItems_args:
21516 
 
21517 
  thrift_spec = (
21518 
  )
21519 
 
21520 
  def read(self, iprot):
21521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21523 
      return
21524 
    iprot.readStructBegin()
21525 
    while True:
21526 
      (fname, ftype, fid) = iprot.readFieldBegin()
21527 
      if ftype == TType.STOP:
21528 
        break
21529 
      else:
21530 
        iprot.skip(ftype)
21531 
      iprot.readFieldEnd()
21532 
    iprot.readStructEnd()
21533 
 
21534 
  def write(self, oprot):
21535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21537 
      return
21538 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
21539 
    oprot.writeFieldStop()
21540 
    oprot.writeStructEnd()
21541 
 
21542 
  def validate(self):
21543 
    return
21544 
 
21545 
 
21546 
  def __repr__(self):
21547 
    L = ['%s=%r' % (key, value)
21548 
      for key, value in self.__dict__.iteritems()]
21549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21550 
 
21551 
  def __eq__(self, other):
21552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21553 
 
21554 
  def __ne__(self, other):
21555 
    return not (self == other)
21556 
 
21557 
class getCountForAmazonlistedItems_result:
21558 
  """
21559 
  Attributes:
21560 
   - success
21561 
  """
21562 
 
21563 
  thrift_spec = (
21564 
    (0, TType.I64, 'success', None, None, ), # 0
21565 
  )
21566 
 
21567 
  def __init__(self, success=None,):
21568 
    self.success = success
21569 
 
21570 
  def read(self, iprot):
21571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21573 
      return
21574 
    iprot.readStructBegin()
21575 
    while True:
21576 
      (fname, ftype, fid) = iprot.readFieldBegin()
21577 
      if ftype == TType.STOP:
21578 
        break
21579 
      if fid == 0:
21580 
        if ftype == TType.I64:
21581 
          self.success = iprot.readI64();
21582 
        else:
21583 
          iprot.skip(ftype)
21584 
      else:
21585 
        iprot.skip(ftype)
21586 
      iprot.readFieldEnd()
21587 
    iprot.readStructEnd()
21588 
 
21589 
  def write(self, oprot):
21590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21592 
      return
21593 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
21594 
    if self.success is not None:
21595 
      oprot.writeFieldBegin('success', TType.I64, 0)
21596 
      oprot.writeI64(self.success)
21597 
      oprot.writeFieldEnd()
21598 
    oprot.writeFieldStop()
21599 
    oprot.writeStructEnd()
21600 
 
21601 
  def validate(self):
21602 
    return
21603 
 
21604 
 
21605 
  def __repr__(self):
21606 
    L = ['%s=%r' % (key, value)
21607 
      for key, value in self.__dict__.iteritems()]
21608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21609 
 
21610 
  def __eq__(self, other):
21611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21612 
 
21613 
  def __ne__(self, other):
21614 
    return not (self == other)
21615 
 
7281 kshitij.so 21616 
class getAmazonItemDetails_args:
21617 
  """
21618 
  Attributes:
21619 
   - itemId
21620 
  """
21621 
 
21622 
  thrift_spec = (
21623 
    None, # 0
21624 
    (1, TType.I64, 'itemId', None, None, ), # 1
21625 
  )
21626 
 
21627 
  def __init__(self, itemId=None,):
21628 
    self.itemId = itemId
21629 
 
21630 
  def read(self, iprot):
21631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21633 
      return
21634 
    iprot.readStructBegin()
21635 
    while True:
21636 
      (fname, ftype, fid) = iprot.readFieldBegin()
21637 
      if ftype == TType.STOP:
21638 
        break
21639 
      if fid == 1:
21640 
        if ftype == TType.I64:
21641 
          self.itemId = iprot.readI64();
21642 
        else:
21643 
          iprot.skip(ftype)
21644 
      else:
21645 
        iprot.skip(ftype)
21646 
      iprot.readFieldEnd()
21647 
    iprot.readStructEnd()
21648 
 
21649 
  def write(self, oprot):
21650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21652 
      return
21653 
    oprot.writeStructBegin('getAmazonItemDetails_args')
21654 
    if self.itemId is not None:
21655 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21656 
      oprot.writeI64(self.itemId)
21657 
      oprot.writeFieldEnd()
21658 
    oprot.writeFieldStop()
21659 
    oprot.writeStructEnd()
21660 
 
21661 
  def validate(self):
21662 
    return
21663 
 
21664 
 
21665 
  def __repr__(self):
21666 
    L = ['%s=%r' % (key, value)
21667 
      for key, value in self.__dict__.iteritems()]
21668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21669 
 
21670 
  def __eq__(self, other):
21671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21672 
 
21673 
  def __ne__(self, other):
21674 
    return not (self == other)
21675 
 
21676 
class getAmazonItemDetails_result:
21677 
  """
21678 
  Attributes:
21679 
   - success
21680 
  """
21681 
 
21682 
  thrift_spec = (
21683 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
21684 
  )
21685 
 
21686 
  def __init__(self, success=None,):
21687 
    self.success = success
21688 
 
21689 
  def read(self, iprot):
21690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21692 
      return
21693 
    iprot.readStructBegin()
21694 
    while True:
21695 
      (fname, ftype, fid) = iprot.readFieldBegin()
21696 
      if ftype == TType.STOP:
21697 
        break
21698 
      if fid == 0:
21699 
        if ftype == TType.STRUCT:
21700 
          self.success = Amazonlisted()
21701 
          self.success.read(iprot)
21702 
        else:
21703 
          iprot.skip(ftype)
21704 
      else:
21705 
        iprot.skip(ftype)
21706 
      iprot.readFieldEnd()
21707 
    iprot.readStructEnd()
21708 
 
21709 
  def write(self, oprot):
21710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21712 
      return
21713 
    oprot.writeStructBegin('getAmazonItemDetails_result')
21714 
    if self.success is not None:
21715 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21716 
      self.success.write(oprot)
21717 
      oprot.writeFieldEnd()
21718 
    oprot.writeFieldStop()
21719 
    oprot.writeStructEnd()
21720 
 
21721 
  def validate(self):
21722 
    return
21723 
 
21724 
 
21725 
  def __repr__(self):
21726 
    L = ['%s=%r' % (key, value)
21727 
      for key, value in self.__dict__.iteritems()]
21728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21729 
 
21730 
  def __eq__(self, other):
21731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21732 
 
21733 
  def __ne__(self, other):
21734 
    return not (self == other)
21735 
 
21736 
class updateAmazonItemDetails_args:
21737 
  """
21738 
  Attributes:
8168 kshitij.so 21739 
   - amazonlisted
7281 kshitij.so 21740 
  """
21741 
 
21742 
  thrift_spec = (
21743 
    None, # 0
8168 kshitij.so 21744 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 21745 
  )
21746 
 
8168 kshitij.so 21747 
  def __init__(self, amazonlisted=None,):
21748 
    self.amazonlisted = amazonlisted
7281 kshitij.so 21749 
 
21750 
  def read(self, iprot):
21751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21753 
      return
21754 
    iprot.readStructBegin()
21755 
    while True:
21756 
      (fname, ftype, fid) = iprot.readFieldBegin()
21757 
      if ftype == TType.STOP:
21758 
        break
21759 
      if fid == 1:
8168 kshitij.so 21760 
        if ftype == TType.STRUCT:
21761 
          self.amazonlisted = Amazonlisted()
21762 
          self.amazonlisted.read(iprot)
7281 kshitij.so 21763 
        else:
21764 
          iprot.skip(ftype)
21765 
      else:
21766 
        iprot.skip(ftype)
21767 
      iprot.readFieldEnd()
21768 
    iprot.readStructEnd()
21769 
 
21770 
  def write(self, oprot):
21771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21773 
      return
21774 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 21775 
    if self.amazonlisted is not None:
21776 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
21777 
      self.amazonlisted.write(oprot)
7281 kshitij.so 21778 
      oprot.writeFieldEnd()
21779 
    oprot.writeFieldStop()
21780 
    oprot.writeStructEnd()
21781 
 
21782 
  def validate(self):
21783 
    return
21784 
 
21785 
 
21786 
  def __repr__(self):
21787 
    L = ['%s=%r' % (key, value)
21788 
      for key, value in self.__dict__.iteritems()]
21789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21790 
 
21791 
  def __eq__(self, other):
21792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21793 
 
21794 
  def __ne__(self, other):
21795 
    return not (self == other)
21796 
 
21797 
class updateAmazonItemDetails_result:
21798 
 
21799 
  thrift_spec = (
21800 
  )
21801 
 
21802 
  def read(self, iprot):
21803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21805 
      return
21806 
    iprot.readStructBegin()
21807 
    while True:
21808 
      (fname, ftype, fid) = iprot.readFieldBegin()
21809 
      if ftype == TType.STOP:
21810 
        break
21811 
      else:
21812 
        iprot.skip(ftype)
21813 
      iprot.readFieldEnd()
21814 
    iprot.readStructEnd()
21815 
 
21816 
  def write(self, oprot):
21817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21819 
      return
21820 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
21821 
    oprot.writeFieldStop()
21822 
    oprot.writeStructEnd()
21823 
 
21824 
  def validate(self):
21825 
    return
21826 
 
21827 
 
21828 
  def __repr__(self):
21829 
    L = ['%s=%r' % (key, value)
21830 
      for key, value in self.__dict__.iteritems()]
21831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21832 
 
21833 
  def __eq__(self, other):
21834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21835 
 
21836 
  def __ne__(self, other):
21837 
    return not (self == other)
21838 
 
21839 
class addAmazonItem_args:
21840 
  """
21841 
  Attributes:
21842 
   - amazonlisted
21843 
  """
21844 
 
21845 
  thrift_spec = (
21846 
    None, # 0
21847 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
21848 
  )
21849 
 
21850 
  def __init__(self, amazonlisted=None,):
21851 
    self.amazonlisted = amazonlisted
21852 
 
21853 
  def read(self, iprot):
21854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21856 
      return
21857 
    iprot.readStructBegin()
21858 
    while True:
21859 
      (fname, ftype, fid) = iprot.readFieldBegin()
21860 
      if ftype == TType.STOP:
21861 
        break
21862 
      if fid == 1:
21863 
        if ftype == TType.STRUCT:
21864 
          self.amazonlisted = Amazonlisted()
21865 
          self.amazonlisted.read(iprot)
21866 
        else:
21867 
          iprot.skip(ftype)
21868 
      else:
21869 
        iprot.skip(ftype)
21870 
      iprot.readFieldEnd()
21871 
    iprot.readStructEnd()
21872 
 
21873 
  def write(self, oprot):
21874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21876 
      return
21877 
    oprot.writeStructBegin('addAmazonItem_args')
21878 
    if self.amazonlisted is not None:
21879 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
21880 
      self.amazonlisted.write(oprot)
21881 
      oprot.writeFieldEnd()
21882 
    oprot.writeFieldStop()
21883 
    oprot.writeStructEnd()
21884 
 
21885 
  def validate(self):
21886 
    return
21887 
 
21888 
 
21889 
  def __repr__(self):
21890 
    L = ['%s=%r' % (key, value)
21891 
      for key, value in self.__dict__.iteritems()]
21892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21893 
 
21894 
  def __eq__(self, other):
21895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21896 
 
21897 
  def __ne__(self, other):
21898 
    return not (self == other)
21899 
 
21900 
class addAmazonItem_result:
21901 
 
21902 
  thrift_spec = (
21903 
  )
21904 
 
21905 
  def read(self, iprot):
21906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21908 
      return
21909 
    iprot.readStructBegin()
21910 
    while True:
21911 
      (fname, ftype, fid) = iprot.readFieldBegin()
21912 
      if ftype == TType.STOP:
21913 
        break
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('addAmazonItem_result')
21924 
    oprot.writeFieldStop()
21925 
    oprot.writeStructEnd()
21926 
 
21927 
  def validate(self):
21928 
    return
21929 
 
21930 
 
21931 
  def __repr__(self):
21932 
    L = ['%s=%r' % (key, value)
21933 
      for key, value in self.__dict__.iteritems()]
21934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21935 
 
21936 
  def __eq__(self, other):
21937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21938 
 
21939 
  def __ne__(self, other):
21940 
    return not (self == other)
7291 vikram.rag 21941 
 
21942 
class getAsinItems_args:
21943 
 
21944 
  thrift_spec = (
21945 
  )
21946 
 
21947 
  def read(self, iprot):
21948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21950 
      return
21951 
    iprot.readStructBegin()
21952 
    while True:
21953 
      (fname, ftype, fid) = iprot.readFieldBegin()
21954 
      if ftype == TType.STOP:
21955 
        break
21956 
      else:
21957 
        iprot.skip(ftype)
21958 
      iprot.readFieldEnd()
21959 
    iprot.readStructEnd()
21960 
 
21961 
  def write(self, oprot):
21962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21964 
      return
21965 
    oprot.writeStructBegin('getAsinItems_args')
21966 
    oprot.writeFieldStop()
21967 
    oprot.writeStructEnd()
21968 
 
21969 
  def validate(self):
21970 
    return
21971 
 
21972 
 
21973 
  def __repr__(self):
21974 
    L = ['%s=%r' % (key, value)
21975 
      for key, value in self.__dict__.iteritems()]
21976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21977 
 
21978 
  def __eq__(self, other):
21979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21980 
 
21981 
  def __ne__(self, other):
21982 
    return not (self == other)
21983 
 
21984 
class getAsinItems_result:
21985 
  """
21986 
  Attributes:
21987 
   - success
21988 
  """
21989 
 
21990 
  thrift_spec = (
21991 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21992 
  )
21993 
 
21994 
  def __init__(self, success=None,):
21995 
    self.success = success
21996 
 
21997 
  def read(self, iprot):
21998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22000 
      return
22001 
    iprot.readStructBegin()
22002 
    while True:
22003 
      (fname, ftype, fid) = iprot.readFieldBegin()
22004 
      if ftype == TType.STOP:
22005 
        break
22006 
      if fid == 0:
22007 
        if ftype == TType.LIST:
22008 
          self.success = []
9155 kshitij.so 22009 
          (_etype442, _size439) = iprot.readListBegin()
22010 
          for _i443 in xrange(_size439):
22011 
            _elem444 = Item()
22012 
            _elem444.read(iprot)
22013 
            self.success.append(_elem444)
7291 vikram.rag 22014 
          iprot.readListEnd()
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('getAsinItems_result')
22027 
    if self.success is not None:
22028 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22029 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22030 
      for iter445 in self.success:
22031 
        iter445.write(oprot)
7291 vikram.rag 22032 
      oprot.writeListEnd()
22033 
      oprot.writeFieldEnd()
22034 
    oprot.writeFieldStop()
22035 
    oprot.writeStructEnd()
22036 
 
22037 
  def validate(self):
22038 
    return
22039 
 
22040 
 
22041 
  def __repr__(self):
22042 
    L = ['%s=%r' % (key, value)
22043 
      for key, value in self.__dict__.iteritems()]
22044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22045 
 
22046 
  def __eq__(self, other):
22047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22048 
 
22049 
  def __ne__(self, other):
22050 
    return not (self == other)
22051 
 
22052 
class getAllFbaListedItems_args:
22053 
 
22054 
  thrift_spec = (
22055 
  )
22056 
 
22057 
  def read(self, iprot):
22058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22060 
      return
22061 
    iprot.readStructBegin()
22062 
    while True:
22063 
      (fname, ftype, fid) = iprot.readFieldBegin()
22064 
      if ftype == TType.STOP:
22065 
        break
22066 
      else:
22067 
        iprot.skip(ftype)
22068 
      iprot.readFieldEnd()
22069 
    iprot.readStructEnd()
22070 
 
22071 
  def write(self, oprot):
22072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22074 
      return
22075 
    oprot.writeStructBegin('getAllFbaListedItems_args')
22076 
    oprot.writeFieldStop()
22077 
    oprot.writeStructEnd()
22078 
 
22079 
  def validate(self):
22080 
    return
22081 
 
22082 
 
22083 
  def __repr__(self):
22084 
    L = ['%s=%r' % (key, value)
22085 
      for key, value in self.__dict__.iteritems()]
22086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22087 
 
22088 
  def __eq__(self, other):
22089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22090 
 
22091 
  def __ne__(self, other):
22092 
    return not (self == other)
22093 
 
22094 
class getAllFbaListedItems_result:
22095 
  """
22096 
  Attributes:
22097 
   - success
22098 
  """
22099 
 
22100 
  thrift_spec = (
22101 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22102 
  )
22103 
 
22104 
  def __init__(self, success=None,):
22105 
    self.success = success
22106 
 
22107 
  def read(self, iprot):
22108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22110 
      return
22111 
    iprot.readStructBegin()
22112 
    while True:
22113 
      (fname, ftype, fid) = iprot.readFieldBegin()
22114 
      if ftype == TType.STOP:
22115 
        break
22116 
      if fid == 0:
22117 
        if ftype == TType.LIST:
22118 
          self.success = []
9155 kshitij.so 22119 
          (_etype449, _size446) = iprot.readListBegin()
22120 
          for _i450 in xrange(_size446):
22121 
            _elem451 = Amazonlisted()
22122 
            _elem451.read(iprot)
22123 
            self.success.append(_elem451)
7291 vikram.rag 22124 
          iprot.readListEnd()
22125 
        else:
22126 
          iprot.skip(ftype)
22127 
      else:
22128 
        iprot.skip(ftype)
22129 
      iprot.readFieldEnd()
22130 
    iprot.readStructEnd()
22131 
 
22132 
  def write(self, oprot):
22133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22135 
      return
22136 
    oprot.writeStructBegin('getAllFbaListedItems_result')
22137 
    if self.success is not None:
22138 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22139 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22140 
      for iter452 in self.success:
22141 
        iter452.write(oprot)
7291 vikram.rag 22142 
      oprot.writeListEnd()
22143 
      oprot.writeFieldEnd()
22144 
    oprot.writeFieldStop()
22145 
    oprot.writeStructEnd()
22146 
 
22147 
  def validate(self):
22148 
    return
22149 
 
22150 
 
22151 
  def __repr__(self):
22152 
    L = ['%s=%r' % (key, value)
22153 
      for key, value in self.__dict__.iteritems()]
22154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22155 
 
22156 
  def __eq__(self, other):
22157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22158 
 
22159 
  def __ne__(self, other):
22160 
    return not (self == other)
22161 
 
22162 
class getAllNonFbaListedItems_args:
22163 
 
22164 
  thrift_spec = (
22165 
  )
22166 
 
22167 
  def read(self, iprot):
22168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22170 
      return
22171 
    iprot.readStructBegin()
22172 
    while True:
22173 
      (fname, ftype, fid) = iprot.readFieldBegin()
22174 
      if ftype == TType.STOP:
22175 
        break
22176 
      else:
22177 
        iprot.skip(ftype)
22178 
      iprot.readFieldEnd()
22179 
    iprot.readStructEnd()
22180 
 
22181 
  def write(self, oprot):
22182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22184 
      return
22185 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
22186 
    oprot.writeFieldStop()
22187 
    oprot.writeStructEnd()
22188 
 
22189 
  def validate(self):
22190 
    return
22191 
 
22192 
 
22193 
  def __repr__(self):
22194 
    L = ['%s=%r' % (key, value)
22195 
      for key, value in self.__dict__.iteritems()]
22196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22197 
 
22198 
  def __eq__(self, other):
22199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22200 
 
22201 
  def __ne__(self, other):
22202 
    return not (self == other)
22203 
 
22204 
class getAllNonFbaListedItems_result:
22205 
  """
22206 
  Attributes:
22207 
   - success
22208 
  """
22209 
 
22210 
  thrift_spec = (
22211 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22212 
  )
22213 
 
22214 
  def __init__(self, success=None,):
22215 
    self.success = success
22216 
 
22217 
  def read(self, iprot):
22218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22220 
      return
22221 
    iprot.readStructBegin()
22222 
    while True:
22223 
      (fname, ftype, fid) = iprot.readFieldBegin()
22224 
      if ftype == TType.STOP:
22225 
        break
22226 
      if fid == 0:
22227 
        if ftype == TType.LIST:
22228 
          self.success = []
9155 kshitij.so 22229 
          (_etype456, _size453) = iprot.readListBegin()
22230 
          for _i457 in xrange(_size453):
22231 
            _elem458 = Amazonlisted()
22232 
            _elem458.read(iprot)
22233 
            self.success.append(_elem458)
7291 vikram.rag 22234 
          iprot.readListEnd()
22235 
        else:
22236 
          iprot.skip(ftype)
22237 
      else:
22238 
        iprot.skip(ftype)
22239 
      iprot.readFieldEnd()
22240 
    iprot.readStructEnd()
22241 
 
22242 
  def write(self, oprot):
22243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22245 
      return
22246 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
22247 
    if self.success is not None:
22248 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22249 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22250 
      for iter459 in self.success:
22251 
        iter459.write(oprot)
7291 vikram.rag 22252 
      oprot.writeListEnd()
22253 
      oprot.writeFieldEnd()
22254 
    oprot.writeFieldStop()
22255 
    oprot.writeStructEnd()
22256 
 
22257 
  def validate(self):
22258 
    return
22259 
 
22260 
 
22261 
  def __repr__(self):
22262 
    L = ['%s=%r' % (key, value)
22263 
      for key, value in self.__dict__.iteritems()]
22264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22265 
 
22266 
  def __eq__(self, other):
22267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22268 
 
22269 
  def __ne__(self, other):
22270 
    return not (self == other)
7460 kshitij.so 22271 
 
22272 
class updateItemInventory_args:
22273 
  """
22274 
  Attributes:
22275 
   - itemId
22276 
   - holdInventory
22277 
   - defaultInventory
22278 
  """
22279 
 
22280 
  thrift_spec = (
22281 
    None, # 0
22282 
    (1, TType.I64, 'itemId', None, None, ), # 1
22283 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
22284 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
22285 
  )
22286 
 
22287 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
22288 
    self.itemId = itemId
22289 
    self.holdInventory = holdInventory
22290 
    self.defaultInventory = defaultInventory
22291 
 
22292 
  def read(self, iprot):
22293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22295 
      return
22296 
    iprot.readStructBegin()
22297 
    while True:
22298 
      (fname, ftype, fid) = iprot.readFieldBegin()
22299 
      if ftype == TType.STOP:
22300 
        break
22301 
      if fid == 1:
22302 
        if ftype == TType.I64:
22303 
          self.itemId = iprot.readI64();
22304 
        else:
22305 
          iprot.skip(ftype)
22306 
      elif fid == 2:
22307 
        if ftype == TType.I64:
22308 
          self.holdInventory = iprot.readI64();
22309 
        else:
22310 
          iprot.skip(ftype)
22311 
      elif fid == 3:
22312 
        if ftype == TType.I64:
22313 
          self.defaultInventory = iprot.readI64();
22314 
        else:
22315 
          iprot.skip(ftype)
22316 
      else:
22317 
        iprot.skip(ftype)
22318 
      iprot.readFieldEnd()
22319 
    iprot.readStructEnd()
22320 
 
22321 
  def write(self, oprot):
22322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22324 
      return
22325 
    oprot.writeStructBegin('updateItemInventory_args')
22326 
    if self.itemId is not None:
22327 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22328 
      oprot.writeI64(self.itemId)
22329 
      oprot.writeFieldEnd()
22330 
    if self.holdInventory is not None:
22331 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
22332 
      oprot.writeI64(self.holdInventory)
22333 
      oprot.writeFieldEnd()
22334 
    if self.defaultInventory is not None:
22335 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
22336 
      oprot.writeI64(self.defaultInventory)
22337 
      oprot.writeFieldEnd()
22338 
    oprot.writeFieldStop()
22339 
    oprot.writeStructEnd()
22340 
 
22341 
  def validate(self):
22342 
    return
22343 
 
22344 
 
22345 
  def __repr__(self):
22346 
    L = ['%s=%r' % (key, value)
22347 
      for key, value in self.__dict__.iteritems()]
22348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22349 
 
22350 
  def __eq__(self, other):
22351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22352 
 
22353 
  def __ne__(self, other):
22354 
    return not (self == other)
22355 
 
22356 
class updateItemInventory_result:
22357 
  """
22358 
  Attributes:
22359 
   - success
22360 
  """
22361 
 
22362 
  thrift_spec = (
22363 
    (0, TType.BOOL, 'success', None, None, ), # 0
22364 
  )
22365 
 
22366 
  def __init__(self, success=None,):
22367 
    self.success = success
22368 
 
22369 
  def read(self, iprot):
22370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22372 
      return
22373 
    iprot.readStructBegin()
22374 
    while True:
22375 
      (fname, ftype, fid) = iprot.readFieldBegin()
22376 
      if ftype == TType.STOP:
22377 
        break
22378 
      if fid == 0:
22379 
        if ftype == TType.BOOL:
22380 
          self.success = iprot.readBool();
22381 
        else:
22382 
          iprot.skip(ftype)
22383 
      else:
22384 
        iprot.skip(ftype)
22385 
      iprot.readFieldEnd()
22386 
    iprot.readStructEnd()
22387 
 
22388 
  def write(self, oprot):
22389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22391 
      return
22392 
    oprot.writeStructBegin('updateItemInventory_result')
22393 
    if self.success is not None:
22394 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22395 
      oprot.writeBool(self.success)
22396 
      oprot.writeFieldEnd()
22397 
    oprot.writeFieldStop()
22398 
    oprot.writeStructEnd()
22399 
 
22400 
  def validate(self):
22401 
    return
22402 
 
22403 
 
22404 
  def __repr__(self):
22405 
    L = ['%s=%r' % (key, value)
22406 
      for key, value in self.__dict__.iteritems()]
22407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22408 
 
22409 
  def __eq__(self, other):
22410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22411 
 
22412 
  def __ne__(self, other):
22413 
    return not (self == other)
7770 kshitij.so 22414 
 
22415 
class updateTimestampForAmazonFeeds_args:
22416 
  """
22417 
  Attributes:
22418 
   - type
22419 
   - sku
22420 
   - timestamp
22421 
  """
22422 
 
22423 
  thrift_spec = (
22424 
    None, # 0
22425 
    (1, TType.STRING, 'type', None, None, ), # 1
22426 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
22427 
    (3, TType.I64, 'timestamp', None, None, ), # 3
22428 
  )
22429 
 
22430 
  def __init__(self, type=None, sku=None, timestamp=None,):
22431 
    self.type = type
22432 
    self.sku = sku
22433 
    self.timestamp = timestamp
22434 
 
22435 
  def read(self, iprot):
22436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22438 
      return
22439 
    iprot.readStructBegin()
22440 
    while True:
22441 
      (fname, ftype, fid) = iprot.readFieldBegin()
22442 
      if ftype == TType.STOP:
22443 
        break
22444 
      if fid == 1:
22445 
        if ftype == TType.STRING:
22446 
          self.type = iprot.readString();
22447 
        else:
22448 
          iprot.skip(ftype)
22449 
      elif fid == 2:
22450 
        if ftype == TType.LIST:
22451 
          self.sku = []
9155 kshitij.so 22452 
          (_etype463, _size460) = iprot.readListBegin()
22453 
          for _i464 in xrange(_size460):
22454 
            _elem465 = iprot.readI64();
22455 
            self.sku.append(_elem465)
7770 kshitij.so 22456 
          iprot.readListEnd()
22457 
        else:
22458 
          iprot.skip(ftype)
22459 
      elif fid == 3:
22460 
        if ftype == TType.I64:
22461 
          self.timestamp = iprot.readI64();
22462 
        else:
22463 
          iprot.skip(ftype)
22464 
      else:
22465 
        iprot.skip(ftype)
22466 
      iprot.readFieldEnd()
22467 
    iprot.readStructEnd()
22468 
 
22469 
  def write(self, oprot):
22470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22472 
      return
22473 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
22474 
    if self.type is not None:
22475 
      oprot.writeFieldBegin('type', TType.STRING, 1)
22476 
      oprot.writeString(self.type)
22477 
      oprot.writeFieldEnd()
22478 
    if self.sku is not None:
22479 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
22480 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 22481 
      for iter466 in self.sku:
22482 
        oprot.writeI64(iter466)
7770 kshitij.so 22483 
      oprot.writeListEnd()
22484 
      oprot.writeFieldEnd()
22485 
    if self.timestamp is not None:
22486 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
22487 
      oprot.writeI64(self.timestamp)
22488 
      oprot.writeFieldEnd()
22489 
    oprot.writeFieldStop()
22490 
    oprot.writeStructEnd()
22491 
 
22492 
  def validate(self):
22493 
    return
22494 
 
22495 
 
22496 
  def __repr__(self):
22497 
    L = ['%s=%r' % (key, value)
22498 
      for key, value in self.__dict__.iteritems()]
22499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22500 
 
22501 
  def __eq__(self, other):
22502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22503 
 
22504 
  def __ne__(self, other):
22505 
    return not (self == other)
22506 
 
22507 
class updateTimestampForAmazonFeeds_result:
22508 
  """
22509 
  Attributes:
22510 
   - success
22511 
  """
22512 
 
22513 
  thrift_spec = (
22514 
    (0, TType.BOOL, 'success', None, None, ), # 0
22515 
  )
22516 
 
22517 
  def __init__(self, success=None,):
22518 
    self.success = success
22519 
 
22520 
  def read(self, iprot):
22521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22523 
      return
22524 
    iprot.readStructBegin()
22525 
    while True:
22526 
      (fname, ftype, fid) = iprot.readFieldBegin()
22527 
      if ftype == TType.STOP:
22528 
        break
22529 
      if fid == 0:
22530 
        if ftype == TType.BOOL:
22531 
          self.success = iprot.readBool();
22532 
        else:
22533 
          iprot.skip(ftype)
22534 
      else:
22535 
        iprot.skip(ftype)
22536 
      iprot.readFieldEnd()
22537 
    iprot.readStructEnd()
22538 
 
22539 
  def write(self, oprot):
22540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22542 
      return
22543 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
22544 
    if self.success is not None:
22545 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22546 
      oprot.writeBool(self.success)
22547 
      oprot.writeFieldEnd()
22548 
    oprot.writeFieldStop()
22549 
    oprot.writeStructEnd()
22550 
 
22551 
  def validate(self):
22552 
    return
22553 
 
22554 
 
22555 
  def __repr__(self):
22556 
    L = ['%s=%r' % (key, value)
22557 
      for key, value in self.__dict__.iteritems()]
22558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22559 
 
22560 
  def __eq__(self, other):
22561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22562 
 
22563 
  def __ne__(self, other):
22564 
    return not (self == other)
7897 amar.kumar 22565 
 
22566 
class getAllParentCategories_args:
22567 
 
22568 
  thrift_spec = (
22569 
  )
22570 
 
22571 
  def read(self, iprot):
22572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22574 
      return
22575 
    iprot.readStructBegin()
22576 
    while True:
22577 
      (fname, ftype, fid) = iprot.readFieldBegin()
22578 
      if ftype == TType.STOP:
22579 
        break
22580 
      else:
22581 
        iprot.skip(ftype)
22582 
      iprot.readFieldEnd()
22583 
    iprot.readStructEnd()
22584 
 
22585 
  def write(self, oprot):
22586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22588 
      return
22589 
    oprot.writeStructBegin('getAllParentCategories_args')
22590 
    oprot.writeFieldStop()
22591 
    oprot.writeStructEnd()
22592 
 
22593 
  def validate(self):
22594 
    return
22595 
 
22596 
 
22597 
  def __repr__(self):
22598 
    L = ['%s=%r' % (key, value)
22599 
      for key, value in self.__dict__.iteritems()]
22600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22601 
 
22602 
  def __eq__(self, other):
22603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22604 
 
22605 
  def __ne__(self, other):
22606 
    return not (self == other)
22607 
 
22608 
class getAllParentCategories_result:
22609 
  """
22610 
  Attributes:
22611 
   - success
22612 
  """
22613 
 
22614 
  thrift_spec = (
22615 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
22616 
  )
22617 
 
22618 
  def __init__(self, success=None,):
22619 
    self.success = success
22620 
 
22621 
  def read(self, iprot):
22622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22624 
      return
22625 
    iprot.readStructBegin()
22626 
    while True:
22627 
      (fname, ftype, fid) = iprot.readFieldBegin()
22628 
      if ftype == TType.STOP:
22629 
        break
22630 
      if fid == 0:
22631 
        if ftype == TType.LIST:
22632 
          self.success = []
9155 kshitij.so 22633 
          (_etype470, _size467) = iprot.readListBegin()
22634 
          for _i471 in xrange(_size467):
22635 
            _elem472 = Category()
22636 
            _elem472.read(iprot)
22637 
            self.success.append(_elem472)
7897 amar.kumar 22638 
          iprot.readListEnd()
22639 
        else:
22640 
          iprot.skip(ftype)
22641 
      else:
22642 
        iprot.skip(ftype)
22643 
      iprot.readFieldEnd()
22644 
    iprot.readStructEnd()
22645 
 
22646 
  def write(self, oprot):
22647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22649 
      return
22650 
    oprot.writeStructBegin('getAllParentCategories_result')
22651 
    if self.success is not None:
22652 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22653 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22654 
      for iter473 in self.success:
22655 
        iter473.write(oprot)
7897 amar.kumar 22656 
      oprot.writeListEnd()
22657 
      oprot.writeFieldEnd()
22658 
    oprot.writeFieldStop()
22659 
    oprot.writeStructEnd()
22660 
 
22661 
  def validate(self):
22662 
    return
22663 
 
22664 
 
22665 
  def __repr__(self):
22666 
    L = ['%s=%r' % (key, value)
22667 
      for key, value in self.__dict__.iteritems()]
22668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22669 
 
22670 
  def __eq__(self, other):
22671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22672 
 
22673 
  def __ne__(self, other):
22674 
    return not (self == other)
7977 kshitij.so 22675 
 
22676 
class addPageViewEvent_args:
22677 
  """
22678 
  Attributes:
22679 
   - pageViewEvents
22680 
  """
22681 
 
22682 
  thrift_spec = (
22683 
    None, # 0
22684 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
22685 
  )
22686 
 
22687 
  def __init__(self, pageViewEvents=None,):
22688 
    self.pageViewEvents = pageViewEvents
22689 
 
22690 
  def read(self, iprot):
22691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22693 
      return
22694 
    iprot.readStructBegin()
22695 
    while True:
22696 
      (fname, ftype, fid) = iprot.readFieldBegin()
22697 
      if ftype == TType.STOP:
22698 
        break
22699 
      if fid == 1:
22700 
        if ftype == TType.STRUCT:
22701 
          self.pageViewEvents = PageViewEvents()
22702 
          self.pageViewEvents.read(iprot)
22703 
        else:
22704 
          iprot.skip(ftype)
22705 
      else:
22706 
        iprot.skip(ftype)
22707 
      iprot.readFieldEnd()
22708 
    iprot.readStructEnd()
22709 
 
22710 
  def write(self, oprot):
22711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22713 
      return
22714 
    oprot.writeStructBegin('addPageViewEvent_args')
22715 
    if self.pageViewEvents is not None:
22716 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
22717 
      self.pageViewEvents.write(oprot)
22718 
      oprot.writeFieldEnd()
22719 
    oprot.writeFieldStop()
22720 
    oprot.writeStructEnd()
22721 
 
22722 
  def validate(self):
22723 
    return
22724 
 
22725 
 
22726 
  def __repr__(self):
22727 
    L = ['%s=%r' % (key, value)
22728 
      for key, value in self.__dict__.iteritems()]
22729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22730 
 
22731 
  def __eq__(self, other):
22732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22733 
 
22734 
  def __ne__(self, other):
22735 
    return not (self == other)
22736 
 
22737 
class addPageViewEvent_result:
22738 
 
22739 
  thrift_spec = (
22740 
  )
22741 
 
22742 
  def read(self, iprot):
22743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22745 
      return
22746 
    iprot.readStructBegin()
22747 
    while True:
22748 
      (fname, ftype, fid) = iprot.readFieldBegin()
22749 
      if ftype == TType.STOP:
22750 
        break
22751 
      else:
22752 
        iprot.skip(ftype)
22753 
      iprot.readFieldEnd()
22754 
    iprot.readStructEnd()
22755 
 
22756 
  def write(self, oprot):
22757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22759 
      return
22760 
    oprot.writeStructBegin('addPageViewEvent_result')
22761 
    oprot.writeFieldStop()
22762 
    oprot.writeStructEnd()
22763 
 
22764 
  def validate(self):
22765 
    return
22766 
 
22767 
 
22768 
  def __repr__(self):
22769 
    L = ['%s=%r' % (key, value)
22770 
      for key, value in self.__dict__.iteritems()]
22771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22772 
 
22773 
  def __eq__(self, other):
22774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22775 
 
22776 
  def __ne__(self, other):
22777 
    return not (self == other)
22778 
 
22779 
class addCartEvent_args:
22780 
  """
22781 
  Attributes:
22782 
   - cartEvents
22783 
  """
22784 
 
22785 
  thrift_spec = (
22786 
    None, # 0
22787 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
22788 
  )
22789 
 
22790 
  def __init__(self, cartEvents=None,):
22791 
    self.cartEvents = cartEvents
22792 
 
22793 
  def read(self, iprot):
22794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22796 
      return
22797 
    iprot.readStructBegin()
22798 
    while True:
22799 
      (fname, ftype, fid) = iprot.readFieldBegin()
22800 
      if ftype == TType.STOP:
22801 
        break
22802 
      if fid == 1:
22803 
        if ftype == TType.STRUCT:
22804 
          self.cartEvents = CartEvents()
22805 
          self.cartEvents.read(iprot)
22806 
        else:
22807 
          iprot.skip(ftype)
22808 
      else:
22809 
        iprot.skip(ftype)
22810 
      iprot.readFieldEnd()
22811 
    iprot.readStructEnd()
22812 
 
22813 
  def write(self, oprot):
22814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22816 
      return
22817 
    oprot.writeStructBegin('addCartEvent_args')
22818 
    if self.cartEvents is not None:
22819 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
22820 
      self.cartEvents.write(oprot)
22821 
      oprot.writeFieldEnd()
22822 
    oprot.writeFieldStop()
22823 
    oprot.writeStructEnd()
22824 
 
22825 
  def validate(self):
22826 
    return
22827 
 
22828 
 
22829 
  def __repr__(self):
22830 
    L = ['%s=%r' % (key, value)
22831 
      for key, value in self.__dict__.iteritems()]
22832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22833 
 
22834 
  def __eq__(self, other):
22835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22836 
 
22837 
  def __ne__(self, other):
22838 
    return not (self == other)
22839 
 
22840 
class addCartEvent_result:
22841 
 
22842 
  thrift_spec = (
22843 
  )
22844 
 
22845 
  def read(self, iprot):
22846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22848 
      return
22849 
    iprot.readStructBegin()
22850 
    while True:
22851 
      (fname, ftype, fid) = iprot.readFieldBegin()
22852 
      if ftype == TType.STOP:
22853 
        break
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('addCartEvent_result')
22864 
    oprot.writeFieldStop()
22865 
    oprot.writeStructEnd()
22866 
 
22867 
  def validate(self):
22868 
    return
22869 
 
22870 
 
22871 
  def __repr__(self):
22872 
    L = ['%s=%r' % (key, value)
22873 
      for key, value in self.__dict__.iteritems()]
22874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22875 
 
22876 
  def __eq__(self, other):
22877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22878 
 
22879 
  def __ne__(self, other):
22880 
    return not (self == other)
8139 kshitij.so 22881 
 
8182 amar.kumar 22882 
class addEbayItem_args:
22883 
  """
22884 
  Attributes:
22885 
   - ebayItem
22886 
  """
22887 
 
22888 
  thrift_spec = (
22889 
    None, # 0
22890 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22891 
  )
22892 
 
22893 
  def __init__(self, ebayItem=None,):
22894 
    self.ebayItem = ebayItem
22895 
 
22896 
  def read(self, iprot):
22897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22899 
      return
22900 
    iprot.readStructBegin()
22901 
    while True:
22902 
      (fname, ftype, fid) = iprot.readFieldBegin()
22903 
      if ftype == TType.STOP:
22904 
        break
22905 
      if fid == 1:
22906 
        if ftype == TType.STRUCT:
22907 
          self.ebayItem = EbayItem()
22908 
          self.ebayItem.read(iprot)
22909 
        else:
22910 
          iprot.skip(ftype)
22911 
      else:
22912 
        iprot.skip(ftype)
22913 
      iprot.readFieldEnd()
22914 
    iprot.readStructEnd()
22915 
 
22916 
  def write(self, oprot):
22917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22919 
      return
22920 
    oprot.writeStructBegin('addEbayItem_args')
22921 
    if self.ebayItem is not None:
22922 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22923 
      self.ebayItem.write(oprot)
22924 
      oprot.writeFieldEnd()
22925 
    oprot.writeFieldStop()
22926 
    oprot.writeStructEnd()
22927 
 
22928 
  def validate(self):
22929 
    return
22930 
 
22931 
 
22932 
  def __repr__(self):
22933 
    L = ['%s=%r' % (key, value)
22934 
      for key, value in self.__dict__.iteritems()]
22935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22936 
 
22937 
  def __eq__(self, other):
22938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22939 
 
22940 
  def __ne__(self, other):
22941 
    return not (self == other)
22942 
 
22943 
class addEbayItem_result:
22944 
 
22945 
  thrift_spec = (
22946 
  )
22947 
 
22948 
  def read(self, iprot):
22949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22951 
      return
22952 
    iprot.readStructBegin()
22953 
    while True:
22954 
      (fname, ftype, fid) = iprot.readFieldBegin()
22955 
      if ftype == TType.STOP:
22956 
        break
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('addEbayItem_result')
22967 
    oprot.writeFieldStop()
22968 
    oprot.writeStructEnd()
22969 
 
22970 
  def validate(self):
22971 
    return
22972 
 
22973 
 
22974 
  def __repr__(self):
22975 
    L = ['%s=%r' % (key, value)
22976 
      for key, value in self.__dict__.iteritems()]
22977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22978 
 
22979 
  def __eq__(self, other):
22980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22981 
 
22982 
  def __ne__(self, other):
22983 
    return not (self == other)
22984 
 
22985 
class getEbayItem_args:
22986 
  """
22987 
  Attributes:
22988 
   - listingId
22989 
  """
22990 
 
22991 
  thrift_spec = (
22992 
    None, # 0
22993 
    (1, TType.STRING, 'listingId', None, None, ), # 1
22994 
  )
22995 
 
22996 
  def __init__(self, listingId=None,):
22997 
    self.listingId = listingId
22998 
 
22999 
  def read(self, iprot):
23000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23002 
      return
23003 
    iprot.readStructBegin()
23004 
    while True:
23005 
      (fname, ftype, fid) = iprot.readFieldBegin()
23006 
      if ftype == TType.STOP:
23007 
        break
23008 
      if fid == 1:
23009 
        if ftype == TType.STRING:
23010 
          self.listingId = iprot.readString();
23011 
        else:
23012 
          iprot.skip(ftype)
23013 
      else:
23014 
        iprot.skip(ftype)
23015 
      iprot.readFieldEnd()
23016 
    iprot.readStructEnd()
23017 
 
23018 
  def write(self, oprot):
23019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23021 
      return
23022 
    oprot.writeStructBegin('getEbayItem_args')
23023 
    if self.listingId is not None:
23024 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
23025 
      oprot.writeString(self.listingId)
23026 
      oprot.writeFieldEnd()
23027 
    oprot.writeFieldStop()
23028 
    oprot.writeStructEnd()
23029 
 
23030 
  def validate(self):
23031 
    return
23032 
 
23033 
 
23034 
  def __repr__(self):
23035 
    L = ['%s=%r' % (key, value)
23036 
      for key, value in self.__dict__.iteritems()]
23037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23038 
 
23039 
  def __eq__(self, other):
23040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23041 
 
23042 
  def __ne__(self, other):
23043 
    return not (self == other)
23044 
 
23045 
class getEbayItem_result:
23046 
  """
23047 
  Attributes:
23048 
   - success
23049 
  """
23050 
 
23051 
  thrift_spec = (
23052 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
23053 
  )
23054 
 
23055 
  def __init__(self, success=None,):
23056 
    self.success = success
23057 
 
23058 
  def read(self, iprot):
23059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23061 
      return
23062 
    iprot.readStructBegin()
23063 
    while True:
23064 
      (fname, ftype, fid) = iprot.readFieldBegin()
23065 
      if ftype == TType.STOP:
23066 
        break
23067 
      if fid == 0:
23068 
        if ftype == TType.STRUCT:
23069 
          self.success = EbayItem()
23070 
          self.success.read(iprot)
23071 
        else:
23072 
          iprot.skip(ftype)
23073 
      else:
23074 
        iprot.skip(ftype)
23075 
      iprot.readFieldEnd()
23076 
    iprot.readStructEnd()
23077 
 
23078 
  def write(self, oprot):
23079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23081 
      return
23082 
    oprot.writeStructBegin('getEbayItem_result')
23083 
    if self.success is not None:
23084 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23085 
      self.success.write(oprot)
23086 
      oprot.writeFieldEnd()
23087 
    oprot.writeFieldStop()
23088 
    oprot.writeStructEnd()
23089 
 
23090 
  def validate(self):
23091 
    return
23092 
 
23093 
 
23094 
  def __repr__(self):
23095 
    L = ['%s=%r' % (key, value)
23096 
      for key, value in self.__dict__.iteritems()]
23097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23098 
 
23099 
  def __eq__(self, other):
23100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23101 
 
23102 
  def __ne__(self, other):
23103 
    return not (self == other)
23104 
 
23105 
class updateEbayItem_args:
23106 
  """
23107 
  Attributes:
23108 
   - ebayItem
23109 
  """
23110 
 
23111 
  thrift_spec = (
23112 
    None, # 0
23113 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
23114 
  )
23115 
 
23116 
  def __init__(self, ebayItem=None,):
23117 
    self.ebayItem = ebayItem
23118 
 
23119 
  def read(self, iprot):
23120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23122 
      return
23123 
    iprot.readStructBegin()
23124 
    while True:
23125 
      (fname, ftype, fid) = iprot.readFieldBegin()
23126 
      if ftype == TType.STOP:
23127 
        break
23128 
      if fid == 1:
23129 
        if ftype == TType.STRUCT:
23130 
          self.ebayItem = EbayItem()
23131 
          self.ebayItem.read(iprot)
23132 
        else:
23133 
          iprot.skip(ftype)
23134 
      else:
23135 
        iprot.skip(ftype)
23136 
      iprot.readFieldEnd()
23137 
    iprot.readStructEnd()
23138 
 
23139 
  def write(self, oprot):
23140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23142 
      return
23143 
    oprot.writeStructBegin('updateEbayItem_args')
23144 
    if self.ebayItem is not None:
23145 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
23146 
      self.ebayItem.write(oprot)
23147 
      oprot.writeFieldEnd()
23148 
    oprot.writeFieldStop()
23149 
    oprot.writeStructEnd()
23150 
 
23151 
  def validate(self):
23152 
    return
23153 
 
23154 
 
23155 
  def __repr__(self):
23156 
    L = ['%s=%r' % (key, value)
23157 
      for key, value in self.__dict__.iteritems()]
23158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23159 
 
23160 
  def __eq__(self, other):
23161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23162 
 
23163 
  def __ne__(self, other):
23164 
    return not (self == other)
23165 
 
23166 
class updateEbayItem_result:
23167 
 
23168 
  thrift_spec = (
23169 
  )
23170 
 
23171 
  def read(self, iprot):
23172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23174 
      return
23175 
    iprot.readStructBegin()
23176 
    while True:
23177 
      (fname, ftype, fid) = iprot.readFieldBegin()
23178 
      if ftype == TType.STOP:
23179 
        break
23180 
      else:
23181 
        iprot.skip(ftype)
23182 
      iprot.readFieldEnd()
23183 
    iprot.readStructEnd()
23184 
 
23185 
  def write(self, oprot):
23186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23188 
      return
23189 
    oprot.writeStructBegin('updateEbayItem_result')
23190 
    oprot.writeFieldStop()
23191 
    oprot.writeStructEnd()
23192 
 
23193 
  def validate(self):
23194 
    return
23195 
 
23196 
 
23197 
  def __repr__(self):
23198 
    L = ['%s=%r' % (key, value)
23199 
      for key, value in self.__dict__.iteritems()]
23200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23201 
 
23202 
  def __eq__(self, other):
23203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23204 
 
23205 
  def __ne__(self, other):
23206 
    return not (self == other)
23207 
 
8139 kshitij.so 23208 
class getAmazonListedItems_args:
23209 
  """
23210 
  Attributes:
23211 
   - offset
23212 
   - limit
23213 
  """
23214 
 
23215 
  thrift_spec = (
23216 
    None, # 0
23217 
    (1, TType.I64, 'offset', None, None, ), # 1
23218 
    (2, TType.I64, 'limit', None, None, ), # 2
23219 
  )
23220 
 
23221 
  def __init__(self, offset=None, limit=None,):
23222 
    self.offset = offset
23223 
    self.limit = limit
23224 
 
23225 
  def read(self, iprot):
23226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23228 
      return
23229 
    iprot.readStructBegin()
23230 
    while True:
23231 
      (fname, ftype, fid) = iprot.readFieldBegin()
23232 
      if ftype == TType.STOP:
23233 
        break
23234 
      if fid == 1:
23235 
        if ftype == TType.I64:
23236 
          self.offset = iprot.readI64();
23237 
        else:
23238 
          iprot.skip(ftype)
23239 
      elif fid == 2:
23240 
        if ftype == TType.I64:
23241 
          self.limit = iprot.readI64();
23242 
        else:
23243 
          iprot.skip(ftype)
23244 
      else:
23245 
        iprot.skip(ftype)
23246 
      iprot.readFieldEnd()
23247 
    iprot.readStructEnd()
23248 
 
23249 
  def write(self, oprot):
23250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23252 
      return
23253 
    oprot.writeStructBegin('getAmazonListedItems_args')
23254 
    if self.offset is not None:
23255 
      oprot.writeFieldBegin('offset', TType.I64, 1)
23256 
      oprot.writeI64(self.offset)
23257 
      oprot.writeFieldEnd()
23258 
    if self.limit is not None:
23259 
      oprot.writeFieldBegin('limit', TType.I64, 2)
23260 
      oprot.writeI64(self.limit)
23261 
      oprot.writeFieldEnd()
23262 
    oprot.writeFieldStop()
23263 
    oprot.writeStructEnd()
23264 
 
23265 
  def validate(self):
23266 
    return
23267 
 
23268 
 
23269 
  def __repr__(self):
23270 
    L = ['%s=%r' % (key, value)
23271 
      for key, value in self.__dict__.iteritems()]
23272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23273 
 
23274 
  def __eq__(self, other):
23275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23276 
 
23277 
  def __ne__(self, other):
23278 
    return not (self == other)
23279 
 
23280 
class getAmazonListedItems_result:
23281 
  """
23282 
  Attributes:
23283 
   - success
23284 
  """
23285 
 
23286 
  thrift_spec = (
23287 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23288 
  )
23289 
 
23290 
  def __init__(self, success=None,):
23291 
    self.success = success
23292 
 
23293 
  def read(self, iprot):
23294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23296 
      return
23297 
    iprot.readStructBegin()
23298 
    while True:
23299 
      (fname, ftype, fid) = iprot.readFieldBegin()
23300 
      if ftype == TType.STOP:
23301 
        break
23302 
      if fid == 0:
23303 
        if ftype == TType.LIST:
23304 
          self.success = []
9155 kshitij.so 23305 
          (_etype477, _size474) = iprot.readListBegin()
23306 
          for _i478 in xrange(_size474):
23307 
            _elem479 = Amazonlisted()
23308 
            _elem479.read(iprot)
23309 
            self.success.append(_elem479)
8139 kshitij.so 23310 
          iprot.readListEnd()
23311 
        else:
23312 
          iprot.skip(ftype)
23313 
      else:
23314 
        iprot.skip(ftype)
23315 
      iprot.readFieldEnd()
23316 
    iprot.readStructEnd()
23317 
 
23318 
  def write(self, oprot):
23319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23321 
      return
23322 
    oprot.writeStructBegin('getAmazonListedItems_result')
23323 
    if self.success is not None:
23324 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23325 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23326 
      for iter480 in self.success:
23327 
        iter480.write(oprot)
8139 kshitij.so 23328 
      oprot.writeListEnd()
23329 
      oprot.writeFieldEnd()
23330 
    oprot.writeFieldStop()
23331 
    oprot.writeStructEnd()
23332 
 
23333 
  def validate(self):
23334 
    return
23335 
 
23336 
 
23337 
  def __repr__(self):
23338 
    L = ['%s=%r' % (key, value)
23339 
      for key, value in self.__dict__.iteritems()]
23340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23341 
 
23342 
  def __eq__(self, other):
23343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23344 
 
23345 
  def __ne__(self, other):
23346 
    return not (self == other)
8168 kshitij.so 23347 
 
23348 
class updateAmazonAttributesInBulk_args:
23349 
  """
23350 
  Attributes:
23351 
   - amazonlisted
23352 
  """
23353 
 
23354 
  thrift_spec = (
23355 
    None, # 0
23356 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
23357 
  )
23358 
 
23359 
  def __init__(self, amazonlisted=None,):
23360 
    self.amazonlisted = amazonlisted
23361 
 
23362 
  def read(self, iprot):
23363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23365 
      return
23366 
    iprot.readStructBegin()
23367 
    while True:
23368 
      (fname, ftype, fid) = iprot.readFieldBegin()
23369 
      if ftype == TType.STOP:
23370 
        break
23371 
      if fid == 1:
23372 
        if ftype == TType.MAP:
23373 
          self.amazonlisted = {}
9155 kshitij.so 23374 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
23375 
          for _i485 in xrange(_size481):
23376 
            _key486 = iprot.readI64();
23377 
            _val487 = Amazonlisted()
23378 
            _val487.read(iprot)
23379 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 23380 
          iprot.readMapEnd()
23381 
        else:
23382 
          iprot.skip(ftype)
23383 
      else:
23384 
        iprot.skip(ftype)
23385 
      iprot.readFieldEnd()
23386 
    iprot.readStructEnd()
23387 
 
23388 
  def write(self, oprot):
23389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23391 
      return
23392 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
23393 
    if self.amazonlisted is not None:
23394 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
23395 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 23396 
      for kiter488,viter489 in self.amazonlisted.items():
23397 
        oprot.writeI64(kiter488)
23398 
        viter489.write(oprot)
8168 kshitij.so 23399 
      oprot.writeMapEnd()
23400 
      oprot.writeFieldEnd()
23401 
    oprot.writeFieldStop()
23402 
    oprot.writeStructEnd()
23403 
 
23404 
  def validate(self):
23405 
    return
23406 
 
23407 
 
23408 
  def __repr__(self):
23409 
    L = ['%s=%r' % (key, value)
23410 
      for key, value in self.__dict__.iteritems()]
23411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23412 
 
23413 
  def __eq__(self, other):
23414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23415 
 
23416 
  def __ne__(self, other):
23417 
    return not (self == other)
23418 
 
23419 
class updateAmazonAttributesInBulk_result:
23420 
  """
23421 
  Attributes:
23422 
   - success
23423 
  """
23424 
 
23425 
  thrift_spec = (
23426 
    (0, TType.BOOL, 'success', None, None, ), # 0
23427 
  )
23428 
 
23429 
  def __init__(self, success=None,):
23430 
    self.success = success
23431 
 
23432 
  def read(self, iprot):
23433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23435 
      return
23436 
    iprot.readStructBegin()
23437 
    while True:
23438 
      (fname, ftype, fid) = iprot.readFieldBegin()
23439 
      if ftype == TType.STOP:
23440 
        break
23441 
      if fid == 0:
23442 
        if ftype == TType.BOOL:
23443 
          self.success = iprot.readBool();
23444 
        else:
23445 
          iprot.skip(ftype)
23446 
      else:
23447 
        iprot.skip(ftype)
23448 
      iprot.readFieldEnd()
23449 
    iprot.readStructEnd()
23450 
 
23451 
  def write(self, oprot):
23452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23454 
      return
23455 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
23456 
    if self.success is not None:
23457 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23458 
      oprot.writeBool(self.success)
23459 
      oprot.writeFieldEnd()
23460 
    oprot.writeFieldStop()
23461 
    oprot.writeStructEnd()
23462 
 
23463 
  def validate(self):
23464 
    return
23465 
 
23466 
 
23467 
  def __repr__(self):
23468 
    L = ['%s=%r' % (key, value)
23469 
      for key, value in self.__dict__.iteritems()]
23470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23471 
 
23472 
  def __eq__(self, other):
23473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23474 
 
23475 
  def __ne__(self, other):
23476 
    return not (self == other)
8379 vikram.rag 23477 
 
23478 
class getAllItemstoListOnFba_args:
23479 
 
23480 
  thrift_spec = (
23481 
  )
23482 
 
23483 
  def read(self, iprot):
23484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23486 
      return
23487 
    iprot.readStructBegin()
23488 
    while True:
23489 
      (fname, ftype, fid) = iprot.readFieldBegin()
23490 
      if ftype == TType.STOP:
23491 
        break
23492 
      else:
23493 
        iprot.skip(ftype)
23494 
      iprot.readFieldEnd()
23495 
    iprot.readStructEnd()
23496 
 
23497 
  def write(self, oprot):
23498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23500 
      return
23501 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
23502 
    oprot.writeFieldStop()
23503 
    oprot.writeStructEnd()
23504 
 
23505 
  def validate(self):
23506 
    return
23507 
 
23508 
 
23509 
  def __repr__(self):
23510 
    L = ['%s=%r' % (key, value)
23511 
      for key, value in self.__dict__.iteritems()]
23512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23513 
 
23514 
  def __eq__(self, other):
23515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23516 
 
23517 
  def __ne__(self, other):
23518 
    return not (self == other)
23519 
 
23520 
class getAllItemstoListOnFba_result:
23521 
  """
23522 
  Attributes:
23523 
   - success
23524 
  """
23525 
 
23526 
  thrift_spec = (
23527 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23528 
  )
23529 
 
23530 
  def __init__(self, success=None,):
23531 
    self.success = success
23532 
 
23533 
  def read(self, iprot):
23534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23536 
      return
23537 
    iprot.readStructBegin()
23538 
    while True:
23539 
      (fname, ftype, fid) = iprot.readFieldBegin()
23540 
      if ftype == TType.STOP:
23541 
        break
23542 
      if fid == 0:
23543 
        if ftype == TType.LIST:
23544 
          self.success = []
9155 kshitij.so 23545 
          (_etype493, _size490) = iprot.readListBegin()
23546 
          for _i494 in xrange(_size490):
23547 
            _elem495 = Amazonlisted()
23548 
            _elem495.read(iprot)
23549 
            self.success.append(_elem495)
8379 vikram.rag 23550 
          iprot.readListEnd()
23551 
        else:
23552 
          iprot.skip(ftype)
23553 
      else:
23554 
        iprot.skip(ftype)
23555 
      iprot.readFieldEnd()
23556 
    iprot.readStructEnd()
23557 
 
23558 
  def write(self, oprot):
23559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23561 
      return
23562 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
23563 
    if self.success is not None:
23564 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23565 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23566 
      for iter496 in self.success:
23567 
        iter496.write(oprot)
8379 vikram.rag 23568 
      oprot.writeListEnd()
23569 
      oprot.writeFieldEnd()
23570 
    oprot.writeFieldStop()
23571 
    oprot.writeStructEnd()
23572 
 
23573 
  def validate(self):
23574 
    return
23575 
 
23576 
 
23577 
  def __repr__(self):
23578 
    L = ['%s=%r' % (key, value)
23579 
      for key, value in self.__dict__.iteritems()]
23580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23581 
 
23582 
  def __eq__(self, other):
23583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23584 
 
23585 
  def __ne__(self, other):
23586 
    return not (self == other)
23587 
 
23588 
class getAllItemstoListOnNonFba_args:
23589 
 
23590 
  thrift_spec = (
23591 
  )
23592 
 
23593 
  def read(self, iprot):
23594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23596 
      return
23597 
    iprot.readStructBegin()
23598 
    while True:
23599 
      (fname, ftype, fid) = iprot.readFieldBegin()
23600 
      if ftype == TType.STOP:
23601 
        break
23602 
      else:
23603 
        iprot.skip(ftype)
23604 
      iprot.readFieldEnd()
23605 
    iprot.readStructEnd()
23606 
 
23607 
  def write(self, oprot):
23608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23610 
      return
23611 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
23612 
    oprot.writeFieldStop()
23613 
    oprot.writeStructEnd()
23614 
 
23615 
  def validate(self):
23616 
    return
23617 
 
23618 
 
23619 
  def __repr__(self):
23620 
    L = ['%s=%r' % (key, value)
23621 
      for key, value in self.__dict__.iteritems()]
23622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23623 
 
23624 
  def __eq__(self, other):
23625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23626 
 
23627 
  def __ne__(self, other):
23628 
    return not (self == other)
23629 
 
23630 
class getAllItemstoListOnNonFba_result:
23631 
  """
23632 
  Attributes:
23633 
   - success
23634 
  """
23635 
 
23636 
  thrift_spec = (
23637 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23638 
  )
23639 
 
23640 
  def __init__(self, success=None,):
23641 
    self.success = success
23642 
 
23643 
  def read(self, iprot):
23644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23646 
      return
23647 
    iprot.readStructBegin()
23648 
    while True:
23649 
      (fname, ftype, fid) = iprot.readFieldBegin()
23650 
      if ftype == TType.STOP:
23651 
        break
23652 
      if fid == 0:
23653 
        if ftype == TType.LIST:
23654 
          self.success = []
9155 kshitij.so 23655 
          (_etype500, _size497) = iprot.readListBegin()
23656 
          for _i501 in xrange(_size497):
23657 
            _elem502 = Amazonlisted()
23658 
            _elem502.read(iprot)
23659 
            self.success.append(_elem502)
8379 vikram.rag 23660 
          iprot.readListEnd()
23661 
        else:
23662 
          iprot.skip(ftype)
23663 
      else:
23664 
        iprot.skip(ftype)
23665 
      iprot.readFieldEnd()
23666 
    iprot.readStructEnd()
23667 
 
23668 
  def write(self, oprot):
23669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23671 
      return
23672 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
23673 
    if self.success is not None:
23674 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23675 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23676 
      for iter503 in self.success:
23677 
        iter503.write(oprot)
8379 vikram.rag 23678 
      oprot.writeListEnd()
23679 
      oprot.writeFieldEnd()
23680 
    oprot.writeFieldStop()
23681 
    oprot.writeStructEnd()
23682 
 
23683 
  def validate(self):
23684 
    return
23685 
 
23686 
 
23687 
  def __repr__(self):
23688 
    L = ['%s=%r' % (key, value)
23689 
      for key, value in self.__dict__.iteritems()]
23690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23691 
 
23692 
  def __eq__(self, other):
23693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23694 
 
23695 
  def __ne__(self, other):
23696 
    return not (self == other)
8616 vikram.rag 23697 
 
9242 kshitij.so 23698 
class updateAsin_args:
23699 
  """
23700 
  Attributes:
23701 
   - item
23702 
  """
8616 vikram.rag 23703 
 
23704 
  thrift_spec = (
9242 kshitij.so 23705 
    None, # 0
23706 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 23707 
  )
23708 
 
9242 kshitij.so 23709 
  def __init__(self, item=None,):
23710 
    self.item = item
23711 
 
8616 vikram.rag 23712 
  def read(self, iprot):
23713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23715 
      return
23716 
    iprot.readStructBegin()
23717 
    while True:
23718 
      (fname, ftype, fid) = iprot.readFieldBegin()
23719 
      if ftype == TType.STOP:
23720 
        break
9242 kshitij.so 23721 
      if fid == 1:
23722 
        if ftype == TType.MAP:
23723 
          self.item = {}
23724 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
23725 
          for _i508 in xrange(_size504):
23726 
            _key509 = iprot.readI64();
23727 
            _val510 = Item()
23728 
            _val510.read(iprot)
23729 
            self.item[_key509] = _val510
23730 
          iprot.readMapEnd()
23731 
        else:
23732 
          iprot.skip(ftype)
8616 vikram.rag 23733 
      else:
23734 
        iprot.skip(ftype)
23735 
      iprot.readFieldEnd()
23736 
    iprot.readStructEnd()
23737 
 
23738 
  def write(self, oprot):
23739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23741 
      return
9242 kshitij.so 23742 
    oprot.writeStructBegin('updateAsin_args')
23743 
    if self.item is not None:
23744 
      oprot.writeFieldBegin('item', TType.MAP, 1)
23745 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
23746 
      for kiter511,viter512 in self.item.items():
23747 
        oprot.writeI64(kiter511)
23748 
        viter512.write(oprot)
23749 
      oprot.writeMapEnd()
23750 
      oprot.writeFieldEnd()
8616 vikram.rag 23751 
    oprot.writeFieldStop()
23752 
    oprot.writeStructEnd()
23753 
 
23754 
  def validate(self):
23755 
    return
23756 
 
23757 
 
23758 
  def __repr__(self):
23759 
    L = ['%s=%r' % (key, value)
23760 
      for key, value in self.__dict__.iteritems()]
23761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23762 
 
23763 
  def __eq__(self, other):
23764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23765 
 
23766 
  def __ne__(self, other):
23767 
    return not (self == other)
23768 
 
9242 kshitij.so 23769 
class updateAsin_result:
8616 vikram.rag 23770 
 
23771 
  thrift_spec = (
23772 
  )
23773 
 
23774 
  def read(self, iprot):
23775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23777 
      return
23778 
    iprot.readStructBegin()
23779 
    while True:
23780 
      (fname, ftype, fid) = iprot.readFieldBegin()
23781 
      if ftype == TType.STOP:
23782 
        break
23783 
      else:
23784 
        iprot.skip(ftype)
23785 
      iprot.readFieldEnd()
23786 
    iprot.readStructEnd()
23787 
 
23788 
  def write(self, oprot):
23789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23791 
      return
9242 kshitij.so 23792 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 23793 
    oprot.writeFieldStop()
23794 
    oprot.writeStructEnd()
23795 
 
23796 
  def validate(self):
23797 
    return
23798 
 
23799 
 
23800 
  def __repr__(self):
23801 
    L = ['%s=%r' % (key, value)
23802 
      for key, value in self.__dict__.iteritems()]
23803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23804 
 
23805 
  def __eq__(self, other):
23806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23807 
 
23808 
  def __ne__(self, other):
23809 
    return not (self == other)
8619 kshitij.so 23810 
 
9242 kshitij.so 23811 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 23812 
  """
23813 
  Attributes:
9242 kshitij.so 23814 
   - snapdealitem
8619 kshitij.so 23815 
  """
23816 
 
9242 kshitij.so 23817 
  thrift_spec = None
23818 
  def __init__(self, snapdealitem=None,):
23819 
    self.snapdealitem = snapdealitem
8619 kshitij.so 23820 
 
23821 
  def read(self, iprot):
23822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23824 
      return
23825 
    iprot.readStructBegin()
23826 
    while True:
23827 
      (fname, ftype, fid) = iprot.readFieldBegin()
23828 
      if ftype == TType.STOP:
23829 
        break
9242 kshitij.so 23830 
      if fid == -1:
23831 
        if ftype == TType.STRUCT:
23832 
          self.snapdealitem = SnapdealItem()
23833 
          self.snapdealitem.read(iprot)
8619 kshitij.so 23834 
        else:
23835 
          iprot.skip(ftype)
23836 
      else:
23837 
        iprot.skip(ftype)
23838 
      iprot.readFieldEnd()
23839 
    iprot.readStructEnd()
23840 
 
23841 
  def write(self, oprot):
23842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23844 
      return
9242 kshitij.so 23845 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
23846 
    if self.snapdealitem is not None:
23847 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
23848 
      self.snapdealitem.write(oprot)
8619 kshitij.so 23849 
      oprot.writeFieldEnd()
23850 
    oprot.writeFieldStop()
23851 
    oprot.writeStructEnd()
23852 
 
23853 
  def validate(self):
23854 
    return
23855 
 
23856 
 
23857 
  def __repr__(self):
23858 
    L = ['%s=%r' % (key, value)
23859 
      for key, value in self.__dict__.iteritems()]
23860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23861 
 
23862 
  def __eq__(self, other):
23863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23864 
 
23865 
  def __ne__(self, other):
23866 
    return not (self == other)
23867 
 
9242 kshitij.so 23868 
class addOrUpdateSnapdealItem_result:
23869 
  """
23870 
  Attributes:
23871 
   - success
23872 
  """
8619 kshitij.so 23873 
 
23874 
  thrift_spec = (
9242 kshitij.so 23875 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 23876 
  )
23877 
 
9242 kshitij.so 23878 
  def __init__(self, success=None,):
23879 
    self.success = success
23880 
 
8619 kshitij.so 23881 
  def read(self, iprot):
23882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23884 
      return
23885 
    iprot.readStructBegin()
23886 
    while True:
23887 
      (fname, ftype, fid) = iprot.readFieldBegin()
23888 
      if ftype == TType.STOP:
23889 
        break
9242 kshitij.so 23890 
      if fid == 0:
23891 
        if ftype == TType.BOOL:
23892 
          self.success = iprot.readBool();
23893 
        else:
23894 
          iprot.skip(ftype)
8619 kshitij.so 23895 
      else:
23896 
        iprot.skip(ftype)
23897 
      iprot.readFieldEnd()
23898 
    iprot.readStructEnd()
23899 
 
23900 
  def write(self, oprot):
23901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23903 
      return
9242 kshitij.so 23904 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
23905 
    if self.success is not None:
23906 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23907 
      oprot.writeBool(self.success)
23908 
      oprot.writeFieldEnd()
8619 kshitij.so 23909 
    oprot.writeFieldStop()
23910 
    oprot.writeStructEnd()
23911 
 
23912 
  def validate(self):
23913 
    return
23914 
 
23915 
 
23916 
  def __repr__(self):
23917 
    L = ['%s=%r' % (key, value)
23918 
      for key, value in self.__dict__.iteritems()]
23919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23920 
 
23921 
  def __eq__(self, other):
23922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23923 
 
23924 
  def __ne__(self, other):
23925 
    return not (self == other)
8739 vikram.rag 23926 
 
9242 kshitij.so 23927 
class getSnapdealItem_args:
8739 vikram.rag 23928 
  """
23929 
  Attributes:
9242 kshitij.so 23930 
   - item_id
8739 vikram.rag 23931 
  """
23932 
 
9242 kshitij.so 23933 
  thrift_spec = (
23934 
    None, # 0
23935 
    (1, TType.I64, 'item_id', None, None, ), # 1
23936 
  )
8739 vikram.rag 23937 
 
9242 kshitij.so 23938 
  def __init__(self, item_id=None,):
23939 
    self.item_id = item_id
23940 
 
8739 vikram.rag 23941 
  def read(self, iprot):
23942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23944 
      return
23945 
    iprot.readStructBegin()
23946 
    while True:
23947 
      (fname, ftype, fid) = iprot.readFieldBegin()
23948 
      if ftype == TType.STOP:
23949 
        break
9242 kshitij.so 23950 
      if fid == 1:
23951 
        if ftype == TType.I64:
23952 
          self.item_id = iprot.readI64();
8739 vikram.rag 23953 
        else:
23954 
          iprot.skip(ftype)
23955 
      else:
23956 
        iprot.skip(ftype)
23957 
      iprot.readFieldEnd()
23958 
    iprot.readStructEnd()
23959 
 
23960 
  def write(self, oprot):
23961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23963 
      return
9242 kshitij.so 23964 
    oprot.writeStructBegin('getSnapdealItem_args')
23965 
    if self.item_id is not None:
23966 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23967 
      oprot.writeI64(self.item_id)
8739 vikram.rag 23968 
      oprot.writeFieldEnd()
23969 
    oprot.writeFieldStop()
23970 
    oprot.writeStructEnd()
23971 
 
23972 
  def validate(self):
23973 
    return
23974 
 
23975 
 
23976 
  def __repr__(self):
23977 
    L = ['%s=%r' % (key, value)
23978 
      for key, value in self.__dict__.iteritems()]
23979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23980 
 
23981 
  def __eq__(self, other):
23982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23983 
 
23984 
  def __ne__(self, other):
23985 
    return not (self == other)
23986 
 
9242 kshitij.so 23987 
class getSnapdealItem_result:
8739 vikram.rag 23988 
  """
23989 
  Attributes:
23990 
   - success
23991 
  """
23992 
 
23993 
  thrift_spec = (
9242 kshitij.so 23994 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 23995 
  )
23996 
 
23997 
  def __init__(self, success=None,):
23998 
    self.success = success
23999 
 
24000 
  def read(self, iprot):
24001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24003 
      return
24004 
    iprot.readStructBegin()
24005 
    while True:
24006 
      (fname, ftype, fid) = iprot.readFieldBegin()
24007 
      if ftype == TType.STOP:
24008 
        break
24009 
      if fid == 0:
9242 kshitij.so 24010 
        if ftype == TType.STRUCT:
24011 
          self.success = SnapdealItem()
24012 
          self.success.read(iprot)
8739 vikram.rag 24013 
        else:
24014 
          iprot.skip(ftype)
24015 
      else:
24016 
        iprot.skip(ftype)
24017 
      iprot.readFieldEnd()
24018 
    iprot.readStructEnd()
24019 
 
24020 
  def write(self, oprot):
24021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24023 
      return
9242 kshitij.so 24024 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 24025 
    if self.success is not None:
9242 kshitij.so 24026 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24027 
      self.success.write(oprot)
8739 vikram.rag 24028 
      oprot.writeFieldEnd()
24029 
    oprot.writeFieldStop()
24030 
    oprot.writeStructEnd()
24031 
 
24032 
  def validate(self):
24033 
    return
24034 
 
24035 
 
24036 
  def __repr__(self):
24037 
    L = ['%s=%r' % (key, value)
24038 
      for key, value in self.__dict__.iteritems()]
24039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24040 
 
24041 
  def __eq__(self, other):
24042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24043 
 
24044 
  def __ne__(self, other):
24045 
    return not (self == other)
24046 
 
9242 kshitij.so 24047 
class getSnapdealItemDetails_args:
8739 vikram.rag 24048 
  """
24049 
  Attributes:
24050 
   - item_id
24051 
  """
24052 
 
24053 
  thrift_spec = (
24054 
    None, # 0
24055 
    (1, TType.I64, 'item_id', None, None, ), # 1
24056 
  )
24057 
 
24058 
  def __init__(self, item_id=None,):
24059 
    self.item_id = item_id
24060 
 
24061 
  def read(self, iprot):
24062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24064 
      return
24065 
    iprot.readStructBegin()
24066 
    while True:
24067 
      (fname, ftype, fid) = iprot.readFieldBegin()
24068 
      if ftype == TType.STOP:
24069 
        break
24070 
      if fid == 1:
24071 
        if ftype == TType.I64:
24072 
          self.item_id = iprot.readI64();
24073 
        else:
24074 
          iprot.skip(ftype)
24075 
      else:
24076 
        iprot.skip(ftype)
24077 
      iprot.readFieldEnd()
24078 
    iprot.readStructEnd()
24079 
 
24080 
  def write(self, oprot):
24081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24083 
      return
9242 kshitij.so 24084 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 24085 
    if self.item_id is not None:
24086 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
24087 
      oprot.writeI64(self.item_id)
24088 
      oprot.writeFieldEnd()
24089 
    oprot.writeFieldStop()
24090 
    oprot.writeStructEnd()
24091 
 
24092 
  def validate(self):
24093 
    return
24094 
 
24095 
 
24096 
  def __repr__(self):
24097 
    L = ['%s=%r' % (key, value)
24098 
      for key, value in self.__dict__.iteritems()]
24099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24100 
 
24101 
  def __eq__(self, other):
24102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24103 
 
24104 
  def __ne__(self, other):
24105 
    return not (self == other)
24106 
 
9242 kshitij.so 24107 
class getSnapdealItemDetails_result:
8739 vikram.rag 24108 
  """
24109 
  Attributes:
24110 
   - success
24111 
  """
24112 
 
24113 
  thrift_spec = (
9242 kshitij.so 24114 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 24115 
  )
24116 
 
24117 
  def __init__(self, success=None,):
24118 
    self.success = success
24119 
 
24120 
  def read(self, iprot):
24121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24123 
      return
24124 
    iprot.readStructBegin()
24125 
    while True:
24126 
      (fname, ftype, fid) = iprot.readFieldBegin()
24127 
      if ftype == TType.STOP:
24128 
        break
24129 
      if fid == 0:
24130 
        if ftype == TType.STRUCT:
9242 kshitij.so 24131 
          self.success = SnapdealItemDetails()
8739 vikram.rag 24132 
          self.success.read(iprot)
24133 
        else:
24134 
          iprot.skip(ftype)
24135 
      else:
24136 
        iprot.skip(ftype)
24137 
      iprot.readFieldEnd()
24138 
    iprot.readStructEnd()
24139 
 
24140 
  def write(self, oprot):
24141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24143 
      return
9242 kshitij.so 24144 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 24145 
    if self.success is not None:
24146 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24147 
      self.success.write(oprot)
24148 
      oprot.writeFieldEnd()
24149 
    oprot.writeFieldStop()
24150 
    oprot.writeStructEnd()
24151 
 
24152 
  def validate(self):
24153 
    return
24154 
 
24155 
 
24156 
  def __repr__(self):
24157 
    L = ['%s=%r' % (key, value)
24158 
      for key, value in self.__dict__.iteritems()]
24159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24160 
 
24161 
  def __eq__(self, other):
24162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24163 
 
24164 
  def __ne__(self, other):
24165 
    return not (self == other)
24166 
 
24167 
class getAllSnapdealItems_args:
24168 
 
24169 
  thrift_spec = (
24170 
  )
24171 
 
24172 
  def read(self, iprot):
24173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24175 
      return
24176 
    iprot.readStructBegin()
24177 
    while True:
24178 
      (fname, ftype, fid) = iprot.readFieldBegin()
24179 
      if ftype == TType.STOP:
24180 
        break
24181 
      else:
24182 
        iprot.skip(ftype)
24183 
      iprot.readFieldEnd()
24184 
    iprot.readStructEnd()
24185 
 
24186 
  def write(self, oprot):
24187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24189 
      return
24190 
    oprot.writeStructBegin('getAllSnapdealItems_args')
24191 
    oprot.writeFieldStop()
24192 
    oprot.writeStructEnd()
24193 
 
24194 
  def validate(self):
24195 
    return
24196 
 
24197 
 
24198 
  def __repr__(self):
24199 
    L = ['%s=%r' % (key, value)
24200 
      for key, value in self.__dict__.iteritems()]
24201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24202 
 
24203 
  def __eq__(self, other):
24204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24205 
 
24206 
  def __ne__(self, other):
24207 
    return not (self == other)
24208 
 
24209 
class getAllSnapdealItems_result:
24210 
  """
24211 
  Attributes:
24212 
   - success
24213 
  """
24214 
 
24215 
  thrift_spec = (
9242 kshitij.so 24216 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 24217 
  )
24218 
 
24219 
  def __init__(self, success=None,):
24220 
    self.success = success
24221 
 
24222 
  def read(self, iprot):
24223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24225 
      return
24226 
    iprot.readStructBegin()
24227 
    while True:
24228 
      (fname, ftype, fid) = iprot.readFieldBegin()
24229 
      if ftype == TType.STOP:
24230 
        break
24231 
      if fid == 0:
24232 
        if ftype == TType.LIST:
24233 
          self.success = []
9242 kshitij.so 24234 
          (_etype516, _size513) = iprot.readListBegin()
24235 
          for _i517 in xrange(_size513):
24236 
            _elem518 = SnapdealItemDetails()
24237 
            _elem518.read(iprot)
24238 
            self.success.append(_elem518)
24239 
          iprot.readListEnd()
24240 
        else:
24241 
          iprot.skip(ftype)
24242 
      else:
24243 
        iprot.skip(ftype)
24244 
      iprot.readFieldEnd()
24245 
    iprot.readStructEnd()
24246 
 
24247 
  def write(self, oprot):
24248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24250 
      return
24251 
    oprot.writeStructBegin('getAllSnapdealItems_result')
24252 
    if self.success is not None:
24253 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24254 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24255 
      for iter519 in self.success:
24256 
        iter519.write(oprot)
24257 
      oprot.writeListEnd()
24258 
      oprot.writeFieldEnd()
24259 
    oprot.writeFieldStop()
24260 
    oprot.writeStructEnd()
24261 
 
24262 
  def validate(self):
24263 
    return
24264 
 
24265 
 
24266 
  def __repr__(self):
24267 
    L = ['%s=%r' % (key, value)
24268 
      for key, value in self.__dict__.iteritems()]
24269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24270 
 
24271 
  def __eq__(self, other):
24272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24273 
 
24274 
  def __ne__(self, other):
24275 
    return not (self == other)
24276 
 
24277 
class getSnapdealItems_args:
24278 
  """
24279 
  Attributes:
24280 
   - offset
24281 
   - limit
24282 
  """
24283 
 
24284 
  thrift_spec = (
24285 
    None, # 0
24286 
    (1, TType.I64, 'offset', None, None, ), # 1
24287 
    (2, TType.I64, 'limit', None, None, ), # 2
24288 
  )
24289 
 
24290 
  def __init__(self, offset=None, limit=None,):
24291 
    self.offset = offset
24292 
    self.limit = limit
24293 
 
24294 
  def read(self, iprot):
24295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24297 
      return
24298 
    iprot.readStructBegin()
24299 
    while True:
24300 
      (fname, ftype, fid) = iprot.readFieldBegin()
24301 
      if ftype == TType.STOP:
24302 
        break
24303 
      if fid == 1:
24304 
        if ftype == TType.I64:
24305 
          self.offset = iprot.readI64();
24306 
        else:
24307 
          iprot.skip(ftype)
24308 
      elif fid == 2:
24309 
        if ftype == TType.I64:
24310 
          self.limit = iprot.readI64();
24311 
        else:
24312 
          iprot.skip(ftype)
24313 
      else:
24314 
        iprot.skip(ftype)
24315 
      iprot.readFieldEnd()
24316 
    iprot.readStructEnd()
24317 
 
24318 
  def write(self, oprot):
24319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24321 
      return
24322 
    oprot.writeStructBegin('getSnapdealItems_args')
24323 
    if self.offset is not None:
24324 
      oprot.writeFieldBegin('offset', TType.I64, 1)
24325 
      oprot.writeI64(self.offset)
24326 
      oprot.writeFieldEnd()
24327 
    if self.limit is not None:
24328 
      oprot.writeFieldBegin('limit', TType.I64, 2)
24329 
      oprot.writeI64(self.limit)
24330 
      oprot.writeFieldEnd()
24331 
    oprot.writeFieldStop()
24332 
    oprot.writeStructEnd()
24333 
 
24334 
  def validate(self):
24335 
    return
24336 
 
24337 
 
24338 
  def __repr__(self):
24339 
    L = ['%s=%r' % (key, value)
24340 
      for key, value in self.__dict__.iteritems()]
24341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24342 
 
24343 
  def __eq__(self, other):
24344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24345 
 
24346 
  def __ne__(self, other):
24347 
    return not (self == other)
24348 
 
24349 
class getSnapdealItems_result:
24350 
  """
24351 
  Attributes:
24352 
   - success
24353 
  """
24354 
 
24355 
  thrift_spec = (
24356 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
24357 
  )
24358 
 
24359 
  def __init__(self, success=None,):
24360 
    self.success = success
24361 
 
24362 
  def read(self, iprot):
24363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24365 
      return
24366 
    iprot.readStructBegin()
24367 
    while True:
24368 
      (fname, ftype, fid) = iprot.readFieldBegin()
24369 
      if ftype == TType.STOP:
24370 
        break
24371 
      if fid == 0:
24372 
        if ftype == TType.LIST:
24373 
          self.success = []
9155 kshitij.so 24374 
          (_etype523, _size520) = iprot.readListBegin()
24375 
          for _i524 in xrange(_size520):
9242 kshitij.so 24376 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 24377 
            _elem525.read(iprot)
24378 
            self.success.append(_elem525)
8739 vikram.rag 24379 
          iprot.readListEnd()
24380 
        else:
24381 
          iprot.skip(ftype)
24382 
      else:
24383 
        iprot.skip(ftype)
24384 
      iprot.readFieldEnd()
24385 
    iprot.readStructEnd()
24386 
 
24387 
  def write(self, oprot):
24388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24390 
      return
9242 kshitij.so 24391 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 24392 
    if self.success is not None:
24393 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24394 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 24395 
      for iter526 in self.success:
24396 
        iter526.write(oprot)
8739 vikram.rag 24397 
      oprot.writeListEnd()
24398 
      oprot.writeFieldEnd()
24399 
    oprot.writeFieldStop()
24400 
    oprot.writeStructEnd()
24401 
 
24402 
  def validate(self):
24403 
    return
24404 
 
24405 
 
24406 
  def __repr__(self):
24407 
    L = ['%s=%r' % (key, value)
24408 
      for key, value in self.__dict__.iteritems()]
24409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24410 
 
24411 
  def __eq__(self, other):
24412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24413 
 
24414 
  def __ne__(self, other):
24415 
    return not (self == other)
9242 kshitij.so 24416 
 
24417 
class searchSnapdealItems_args:
24418 
  """
24419 
  Attributes:
24420 
   - searchTerm
24421 
   - offset
24422 
   - limit
24423 
  """
24424 
 
24425 
  thrift_spec = (
24426 
    None, # 0
24427 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
24428 
    (2, TType.I64, 'offset', None, None, ), # 2
24429 
    (3, TType.I64, 'limit', None, None, ), # 3
24430 
  )
24431 
 
24432 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
24433 
    self.searchTerm = searchTerm
24434 
    self.offset = offset
24435 
    self.limit = limit
24436 
 
24437 
  def read(self, iprot):
24438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24440 
      return
24441 
    iprot.readStructBegin()
24442 
    while True:
24443 
      (fname, ftype, fid) = iprot.readFieldBegin()
24444 
      if ftype == TType.STOP:
24445 
        break
24446 
      if fid == 1:
24447 
        if ftype == TType.LIST:
24448 
          self.searchTerm = []
24449 
          (_etype530, _size527) = iprot.readListBegin()
24450 
          for _i531 in xrange(_size527):
24451 
            _elem532 = iprot.readString();
24452 
            self.searchTerm.append(_elem532)
24453 
          iprot.readListEnd()
24454 
        else:
24455 
          iprot.skip(ftype)
24456 
      elif fid == 2:
24457 
        if ftype == TType.I64:
24458 
          self.offset = iprot.readI64();
24459 
        else:
24460 
          iprot.skip(ftype)
24461 
      elif fid == 3:
24462 
        if ftype == TType.I64:
24463 
          self.limit = iprot.readI64();
24464 
        else:
24465 
          iprot.skip(ftype)
24466 
      else:
24467 
        iprot.skip(ftype)
24468 
      iprot.readFieldEnd()
24469 
    iprot.readStructEnd()
24470 
 
24471 
  def write(self, oprot):
24472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24474 
      return
24475 
    oprot.writeStructBegin('searchSnapdealItems_args')
24476 
    if self.searchTerm is not None:
24477 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
24478 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
24479 
      for iter533 in self.searchTerm:
24480 
        oprot.writeString(iter533)
24481 
      oprot.writeListEnd()
24482 
      oprot.writeFieldEnd()
24483 
    if self.offset is not None:
24484 
      oprot.writeFieldBegin('offset', TType.I64, 2)
24485 
      oprot.writeI64(self.offset)
24486 
      oprot.writeFieldEnd()
24487 
    if self.limit is not None:
24488 
      oprot.writeFieldBegin('limit', TType.I64, 3)
24489 
      oprot.writeI64(self.limit)
24490 
      oprot.writeFieldEnd()
24491 
    oprot.writeFieldStop()
24492 
    oprot.writeStructEnd()
24493 
 
24494 
  def validate(self):
24495 
    return
24496 
 
24497 
 
24498 
  def __repr__(self):
24499 
    L = ['%s=%r' % (key, value)
24500 
      for key, value in self.__dict__.iteritems()]
24501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24502 
 
24503 
  def __eq__(self, other):
24504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24505 
 
24506 
  def __ne__(self, other):
24507 
    return not (self == other)
24508 
 
24509 
class searchSnapdealItems_result:
24510 
  """
24511 
  Attributes:
24512 
   - success
24513 
  """
24514 
 
24515 
  thrift_spec = (
24516 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
24517 
  )
24518 
 
24519 
  def __init__(self, success=None,):
24520 
    self.success = success
24521 
 
24522 
  def read(self, iprot):
24523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24525 
      return
24526 
    iprot.readStructBegin()
24527 
    while True:
24528 
      (fname, ftype, fid) = iprot.readFieldBegin()
24529 
      if ftype == TType.STOP:
24530 
        break
24531 
      if fid == 0:
24532 
        if ftype == TType.LIST:
24533 
          self.success = []
24534 
          (_etype537, _size534) = iprot.readListBegin()
24535 
          for _i538 in xrange(_size534):
24536 
            _elem539 = SnapdealItemDetails()
24537 
            _elem539.read(iprot)
24538 
            self.success.append(_elem539)
24539 
          iprot.readListEnd()
24540 
        else:
24541 
          iprot.skip(ftype)
24542 
      else:
24543 
        iprot.skip(ftype)
24544 
      iprot.readFieldEnd()
24545 
    iprot.readStructEnd()
24546 
 
24547 
  def write(self, oprot):
24548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24550 
      return
24551 
    oprot.writeStructBegin('searchSnapdealItems_result')
24552 
    if self.success is not None:
24553 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24554 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24555 
      for iter540 in self.success:
24556 
        iter540.write(oprot)
24557 
      oprot.writeListEnd()
24558 
      oprot.writeFieldEnd()
24559 
    oprot.writeFieldStop()
24560 
    oprot.writeStructEnd()
24561 
 
24562 
  def validate(self):
24563 
    return
24564 
 
24565 
 
24566 
  def __repr__(self):
24567 
    L = ['%s=%r' % (key, value)
24568 
      for key, value in self.__dict__.iteritems()]
24569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24570 
 
24571 
  def __eq__(self, other):
24572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24573 
 
24574 
  def __ne__(self, other):
24575 
    return not (self == other)
24576 
 
24577 
class getCountForSnapdealItems_args:
24578 
 
24579 
  thrift_spec = (
24580 
  )
24581 
 
24582 
  def read(self, iprot):
24583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24585 
      return
24586 
    iprot.readStructBegin()
24587 
    while True:
24588 
      (fname, ftype, fid) = iprot.readFieldBegin()
24589 
      if ftype == TType.STOP:
24590 
        break
24591 
      else:
24592 
        iprot.skip(ftype)
24593 
      iprot.readFieldEnd()
24594 
    iprot.readStructEnd()
24595 
 
24596 
  def write(self, oprot):
24597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24599 
      return
24600 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
24601 
    oprot.writeFieldStop()
24602 
    oprot.writeStructEnd()
24603 
 
24604 
  def validate(self):
24605 
    return
24606 
 
24607 
 
24608 
  def __repr__(self):
24609 
    L = ['%s=%r' % (key, value)
24610 
      for key, value in self.__dict__.iteritems()]
24611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24612 
 
24613 
  def __eq__(self, other):
24614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24615 
 
24616 
  def __ne__(self, other):
24617 
    return not (self == other)
24618 
 
24619 
class getCountForSnapdealItems_result:
24620 
  """
24621 
  Attributes:
24622 
   - success
24623 
  """
24624 
 
24625 
  thrift_spec = (
24626 
    (0, TType.I64, 'success', None, None, ), # 0
24627 
  )
24628 
 
24629 
  def __init__(self, success=None,):
24630 
    self.success = success
24631 
 
24632 
  def read(self, iprot):
24633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24635 
      return
24636 
    iprot.readStructBegin()
24637 
    while True:
24638 
      (fname, ftype, fid) = iprot.readFieldBegin()
24639 
      if ftype == TType.STOP:
24640 
        break
24641 
      if fid == 0:
24642 
        if ftype == TType.I64:
24643 
          self.success = iprot.readI64();
24644 
        else:
24645 
          iprot.skip(ftype)
24646 
      else:
24647 
        iprot.skip(ftype)
24648 
      iprot.readFieldEnd()
24649 
    iprot.readStructEnd()
24650 
 
24651 
  def write(self, oprot):
24652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24654 
      return
24655 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
24656 
    if self.success is not None:
24657 
      oprot.writeFieldBegin('success', TType.I64, 0)
24658 
      oprot.writeI64(self.success)
24659 
      oprot.writeFieldEnd()
24660 
    oprot.writeFieldStop()
24661 
    oprot.writeStructEnd()
24662 
 
24663 
  def validate(self):
24664 
    return
24665 
 
24666 
 
24667 
  def __repr__(self):
24668 
    L = ['%s=%r' % (key, value)
24669 
      for key, value in self.__dict__.iteritems()]
24670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24671 
 
24672 
  def __eq__(self, other):
24673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24674 
 
24675 
  def __ne__(self, other):
24676 
    return not (self == other)
24677 
 
24678 
class getSnapdealSearchResultCount_args:
24679 
  """
24680 
  Attributes:
24681 
   - searchTerm
24682 
  """
24683 
 
24684 
  thrift_spec = (
24685 
    None, # 0
24686 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
24687 
  )
24688 
 
24689 
  def __init__(self, searchTerm=None,):
24690 
    self.searchTerm = searchTerm
24691 
 
24692 
  def read(self, iprot):
24693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24695 
      return
24696 
    iprot.readStructBegin()
24697 
    while True:
24698 
      (fname, ftype, fid) = iprot.readFieldBegin()
24699 
      if ftype == TType.STOP:
24700 
        break
24701 
      if fid == 1:
24702 
        if ftype == TType.LIST:
24703 
          self.searchTerm = []
24704 
          (_etype544, _size541) = iprot.readListBegin()
24705 
          for _i545 in xrange(_size541):
24706 
            _elem546 = iprot.readString();
24707 
            self.searchTerm.append(_elem546)
24708 
          iprot.readListEnd()
24709 
        else:
24710 
          iprot.skip(ftype)
24711 
      else:
24712 
        iprot.skip(ftype)
24713 
      iprot.readFieldEnd()
24714 
    iprot.readStructEnd()
24715 
 
24716 
  def write(self, oprot):
24717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24719 
      return
24720 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
24721 
    if self.searchTerm is not None:
24722 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
24723 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
24724 
      for iter547 in self.searchTerm:
24725 
        oprot.writeString(iter547)
24726 
      oprot.writeListEnd()
24727 
      oprot.writeFieldEnd()
24728 
    oprot.writeFieldStop()
24729 
    oprot.writeStructEnd()
24730 
 
24731 
  def validate(self):
24732 
    return
24733 
 
24734 
 
24735 
  def __repr__(self):
24736 
    L = ['%s=%r' % (key, value)
24737 
      for key, value in self.__dict__.iteritems()]
24738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24739 
 
24740 
  def __eq__(self, other):
24741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24742 
 
24743 
  def __ne__(self, other):
24744 
    return not (self == other)
24745 
 
24746 
class getSnapdealSearchResultCount_result:
24747 
  """
24748 
  Attributes:
24749 
   - success
24750 
  """
24751 
 
24752 
  thrift_spec = (
24753 
    (0, TType.I64, 'success', None, None, ), # 0
24754 
  )
24755 
 
24756 
  def __init__(self, success=None,):
24757 
    self.success = success
24758 
 
24759 
  def read(self, iprot):
24760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24762 
      return
24763 
    iprot.readStructBegin()
24764 
    while True:
24765 
      (fname, ftype, fid) = iprot.readFieldBegin()
24766 
      if ftype == TType.STOP:
24767 
        break
24768 
      if fid == 0:
24769 
        if ftype == TType.I64:
24770 
          self.success = iprot.readI64();
24771 
        else:
24772 
          iprot.skip(ftype)
24773 
      else:
24774 
        iprot.skip(ftype)
24775 
      iprot.readFieldEnd()
24776 
    iprot.readStructEnd()
24777 
 
24778 
  def write(self, oprot):
24779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24781 
      return
24782 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
24783 
    if self.success is not None:
24784 
      oprot.writeFieldBegin('success', TType.I64, 0)
24785 
      oprot.writeI64(self.success)
24786 
      oprot.writeFieldEnd()
24787 
    oprot.writeFieldStop()
24788 
    oprot.writeStructEnd()
24789 
 
24790 
  def validate(self):
24791 
    return
24792 
 
24793 
 
24794 
  def __repr__(self):
24795 
    L = ['%s=%r' % (key, value)
24796 
      for key, value in self.__dict__.iteritems()]
24797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24798 
 
24799 
  def __eq__(self, other):
24800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24801 
 
24802 
  def __ne__(self, other):
24803 
    return not (self == other)
9299 kshitij.so 24804 
 
24805 
class getPrefferedInsurerForItem_args:
24806 
  """
24807 
  Attributes:
24808 
   - itemId
24809 
   - insurerType
24810 
  """
24811 
 
24812 
  thrift_spec = (
24813 
    None, # 0
24814 
    (1, TType.I64, 'itemId', None, None, ), # 1
24815 
    (2, TType.I32, 'insurerType', None, None, ), # 2
24816 
  )
24817 
 
24818 
  def __init__(self, itemId=None, insurerType=None,):
24819 
    self.itemId = itemId
24820 
    self.insurerType = insurerType
24821 
 
24822 
  def read(self, iprot):
24823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24825 
      return
24826 
    iprot.readStructBegin()
24827 
    while True:
24828 
      (fname, ftype, fid) = iprot.readFieldBegin()
24829 
      if ftype == TType.STOP:
24830 
        break
24831 
      if fid == 1:
24832 
        if ftype == TType.I64:
24833 
          self.itemId = iprot.readI64();
24834 
        else:
24835 
          iprot.skip(ftype)
24836 
      elif fid == 2:
24837 
        if ftype == TType.I32:
24838 
          self.insurerType = iprot.readI32();
24839 
        else:
24840 
          iprot.skip(ftype)
24841 
      else:
24842 
        iprot.skip(ftype)
24843 
      iprot.readFieldEnd()
24844 
    iprot.readStructEnd()
24845 
 
24846 
  def write(self, oprot):
24847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24849 
      return
24850 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
24851 
    if self.itemId is not None:
24852 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24853 
      oprot.writeI64(self.itemId)
24854 
      oprot.writeFieldEnd()
24855 
    if self.insurerType is not None:
24856 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
24857 
      oprot.writeI32(self.insurerType)
24858 
      oprot.writeFieldEnd()
24859 
    oprot.writeFieldStop()
24860 
    oprot.writeStructEnd()
24861 
 
24862 
  def validate(self):
24863 
    return
24864 
 
24865 
 
24866 
  def __repr__(self):
24867 
    L = ['%s=%r' % (key, value)
24868 
      for key, value in self.__dict__.iteritems()]
24869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24870 
 
24871 
  def __eq__(self, other):
24872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24873 
 
24874 
  def __ne__(self, other):
24875 
    return not (self == other)
24876 
 
24877 
class getPrefferedInsurerForItem_result:
24878 
  """
24879 
  Attributes:
24880 
   - success
24881 
  """
24882 
 
24883 
  thrift_spec = (
24884 
    (0, TType.I64, 'success', None, None, ), # 0
24885 
  )
24886 
 
24887 
  def __init__(self, success=None,):
24888 
    self.success = success
24889 
 
24890 
  def read(self, iprot):
24891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24893 
      return
24894 
    iprot.readStructBegin()
24895 
    while True:
24896 
      (fname, ftype, fid) = iprot.readFieldBegin()
24897 
      if ftype == TType.STOP:
24898 
        break
24899 
      if fid == 0:
24900 
        if ftype == TType.I64:
24901 
          self.success = iprot.readI64();
24902 
        else:
24903 
          iprot.skip(ftype)
24904 
      else:
24905 
        iprot.skip(ftype)
24906 
      iprot.readFieldEnd()
24907 
    iprot.readStructEnd()
24908 
 
24909 
  def write(self, oprot):
24910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24912 
      return
24913 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
24914 
    if self.success is not None:
24915 
      oprot.writeFieldBegin('success', TType.I64, 0)
24916 
      oprot.writeI64(self.success)
24917 
      oprot.writeFieldEnd()
24918 
    oprot.writeFieldStop()
24919 
    oprot.writeStructEnd()
24920 
 
24921 
  def validate(self):
24922 
    return
24923 
 
24924 
 
24925 
  def __repr__(self):
24926 
    L = ['%s=%r' % (key, value)
24927 
      for key, value in self.__dict__.iteritems()]
24928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24929 
 
24930 
  def __eq__(self, other):
24931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24932 
 
24933 
  def __ne__(self, other):
24934 
    return not (self == other)
9456 vikram.rag 24935 
 
24936 
class getSnapdealItembySkuAtSnapdeal_args:
24937 
  """
24938 
  Attributes:
24939 
   - skuAtSnapdeal
24940 
  """
24941 
 
24942 
  thrift_spec = None
24943 
  def __init__(self, skuAtSnapdeal=None,):
24944 
    self.skuAtSnapdeal = skuAtSnapdeal
24945 
 
24946 
  def read(self, iprot):
24947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24949 
      return
24950 
    iprot.readStructBegin()
24951 
    while True:
24952 
      (fname, ftype, fid) = iprot.readFieldBegin()
24953 
      if ftype == TType.STOP:
24954 
        break
24955 
      if fid == -1:
24956 
        if ftype == TType.STRING:
24957 
          self.skuAtSnapdeal = iprot.readString();
24958 
        else:
24959 
          iprot.skip(ftype)
24960 
      else:
24961 
        iprot.skip(ftype)
24962 
      iprot.readFieldEnd()
24963 
    iprot.readStructEnd()
24964 
 
24965 
  def write(self, oprot):
24966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24968 
      return
24969 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
24970 
    if self.skuAtSnapdeal is not None:
24971 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
24972 
      oprot.writeString(self.skuAtSnapdeal)
24973 
      oprot.writeFieldEnd()
24974 
    oprot.writeFieldStop()
24975 
    oprot.writeStructEnd()
24976 
 
24977 
  def validate(self):
24978 
    return
24979 
 
24980 
 
24981 
  def __repr__(self):
24982 
    L = ['%s=%r' % (key, value)
24983 
      for key, value in self.__dict__.iteritems()]
24984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24985 
 
24986 
  def __eq__(self, other):
24987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24988 
 
24989 
  def __ne__(self, other):
24990 
    return not (self == other)
24991 
 
24992 
class getSnapdealItembySkuAtSnapdeal_result:
24993 
  """
24994 
  Attributes:
24995 
   - success
24996 
  """
24997 
 
24998 
  thrift_spec = (
24999 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
25000 
  )
25001 
 
25002 
  def __init__(self, success=None,):
25003 
    self.success = success
25004 
 
25005 
  def read(self, iprot):
25006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25008 
      return
25009 
    iprot.readStructBegin()
25010 
    while True:
25011 
      (fname, ftype, fid) = iprot.readFieldBegin()
25012 
      if ftype == TType.STOP:
25013 
        break
25014 
      if fid == 0:
25015 
        if ftype == TType.STRUCT:
25016 
          self.success = SnapdealItem()
25017 
          self.success.read(iprot)
25018 
        else:
25019 
          iprot.skip(ftype)
25020 
      else:
25021 
        iprot.skip(ftype)
25022 
      iprot.readFieldEnd()
25023 
    iprot.readStructEnd()
25024 
 
25025 
  def write(self, oprot):
25026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25028 
      return
25029 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
25030 
    if self.success is not None:
25031 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25032 
      self.success.write(oprot)
25033 
      oprot.writeFieldEnd()
25034 
    oprot.writeFieldStop()
25035 
    oprot.writeStructEnd()
25036 
 
25037 
  def validate(self):
25038 
    return
25039 
 
25040 
 
25041 
  def __repr__(self):
25042 
    L = ['%s=%r' % (key, value)
25043 
      for key, value in self.__dict__.iteritems()]
25044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25045 
 
25046 
  def __eq__(self, other):
25047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25048 
 
25049 
  def __ne__(self, other):
25050 
    return not (self == other)
9621 manish.sha 25051 
 
25052 
class getProductFeedSubmit_args:
25053 
  """
25054 
  Attributes:
25055 
   - catalogItemId
25056 
  """
25057 
 
25058 
  thrift_spec = (
25059 
    None, # 0
25060 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
25061 
  )
25062 
 
25063 
  def __init__(self, catalogItemId=None,):
25064 
    self.catalogItemId = catalogItemId
25065 
 
25066 
  def read(self, iprot):
25067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25069 
      return
25070 
    iprot.readStructBegin()
25071 
    while True:
25072 
      (fname, ftype, fid) = iprot.readFieldBegin()
25073 
      if ftype == TType.STOP:
25074 
        break
25075 
      if fid == 1:
25076 
        if ftype == TType.I64:
25077 
          self.catalogItemId = iprot.readI64();
25078 
        else:
25079 
          iprot.skip(ftype)
25080 
      else:
25081 
        iprot.skip(ftype)
25082 
      iprot.readFieldEnd()
25083 
    iprot.readStructEnd()
25084 
 
25085 
  def write(self, oprot):
25086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25088 
      return
25089 
    oprot.writeStructBegin('getProductFeedSubmit_args')
25090 
    if self.catalogItemId is not None:
25091 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
25092 
      oprot.writeI64(self.catalogItemId)
25093 
      oprot.writeFieldEnd()
25094 
    oprot.writeFieldStop()
25095 
    oprot.writeStructEnd()
25096 
 
25097 
  def validate(self):
25098 
    return
25099 
 
25100 
 
25101 
  def __repr__(self):
25102 
    L = ['%s=%r' % (key, value)
25103 
      for key, value in self.__dict__.iteritems()]
25104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25105 
 
25106 
  def __eq__(self, other):
25107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25108 
 
25109 
  def __ne__(self, other):
25110 
    return not (self == other)
25111 
 
25112 
class getProductFeedSubmit_result:
25113 
  """
25114 
  Attributes:
25115 
   - success
25116 
   - cex
25117 
  """
25118 
 
25119 
  thrift_spec = (
25120 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
25121 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25122 
  )
25123 
 
25124 
  def __init__(self, success=None, cex=None,):
25125 
    self.success = success
25126 
    self.cex = cex
25127 
 
25128 
  def read(self, iprot):
25129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25131 
      return
25132 
    iprot.readStructBegin()
25133 
    while True:
25134 
      (fname, ftype, fid) = iprot.readFieldBegin()
25135 
      if ftype == TType.STOP:
25136 
        break
25137 
      if fid == 0:
25138 
        if ftype == TType.STRUCT:
25139 
          self.success = ProductFeedSubmit()
25140 
          self.success.read(iprot)
25141 
        else:
25142 
          iprot.skip(ftype)
25143 
      elif fid == 1:
25144 
        if ftype == TType.STRUCT:
25145 
          self.cex = CatalogServiceException()
25146 
          self.cex.read(iprot)
25147 
        else:
25148 
          iprot.skip(ftype)
25149 
      else:
25150 
        iprot.skip(ftype)
25151 
      iprot.readFieldEnd()
25152 
    iprot.readStructEnd()
25153 
 
25154 
  def write(self, oprot):
25155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25157 
      return
25158 
    oprot.writeStructBegin('getProductFeedSubmit_result')
25159 
    if self.success is not None:
25160 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25161 
      self.success.write(oprot)
25162 
      oprot.writeFieldEnd()
25163 
    if self.cex is not None:
25164 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25165 
      self.cex.write(oprot)
25166 
      oprot.writeFieldEnd()
25167 
    oprot.writeFieldStop()
25168 
    oprot.writeStructEnd()
25169 
 
25170 
  def validate(self):
25171 
    return
25172 
 
25173 
 
25174 
  def __repr__(self):
25175 
    L = ['%s=%r' % (key, value)
25176 
      for key, value in self.__dict__.iteritems()]
25177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25178 
 
25179 
  def __eq__(self, other):
25180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25181 
 
25182 
  def __ne__(self, other):
25183 
    return not (self == other)
25184 
 
25185 
class addProductFeedSubmit_args:
25186 
  """
25187 
  Attributes:
25188 
   - productFeedSubmit
25189 
  """
25190 
 
25191 
  thrift_spec = (
25192 
    None, # 0
25193 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
25194 
  )
25195 
 
25196 
  def __init__(self, productFeedSubmit=None,):
25197 
    self.productFeedSubmit = productFeedSubmit
25198 
 
25199 
  def read(self, iprot):
25200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25202 
      return
25203 
    iprot.readStructBegin()
25204 
    while True:
25205 
      (fname, ftype, fid) = iprot.readFieldBegin()
25206 
      if ftype == TType.STOP:
25207 
        break
25208 
      if fid == 1:
25209 
        if ftype == TType.STRUCT:
25210 
          self.productFeedSubmit = ProductFeedSubmit()
25211 
          self.productFeedSubmit.read(iprot)
25212 
        else:
25213 
          iprot.skip(ftype)
25214 
      else:
25215 
        iprot.skip(ftype)
25216 
      iprot.readFieldEnd()
25217 
    iprot.readStructEnd()
25218 
 
25219 
  def write(self, oprot):
25220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25222 
      return
25223 
    oprot.writeStructBegin('addProductFeedSubmit_args')
25224 
    if self.productFeedSubmit is not None:
25225 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
25226 
      self.productFeedSubmit.write(oprot)
25227 
      oprot.writeFieldEnd()
25228 
    oprot.writeFieldStop()
25229 
    oprot.writeStructEnd()
25230 
 
25231 
  def validate(self):
25232 
    return
25233 
 
25234 
 
25235 
  def __repr__(self):
25236 
    L = ['%s=%r' % (key, value)
25237 
      for key, value in self.__dict__.iteritems()]
25238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25239 
 
25240 
  def __eq__(self, other):
25241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25242 
 
25243 
  def __ne__(self, other):
25244 
    return not (self == other)
25245 
 
25246 
class addProductFeedSubmit_result:
25247 
  """
25248 
  Attributes:
25249 
   - success
25250 
   - cex
25251 
  """
25252 
 
25253 
  thrift_spec = (
25254 
    (0, TType.BOOL, 'success', None, None, ), # 0
25255 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25256 
  )
25257 
 
25258 
  def __init__(self, success=None, cex=None,):
25259 
    self.success = success
25260 
    self.cex = cex
25261 
 
25262 
  def read(self, iprot):
25263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25265 
      return
25266 
    iprot.readStructBegin()
25267 
    while True:
25268 
      (fname, ftype, fid) = iprot.readFieldBegin()
25269 
      if ftype == TType.STOP:
25270 
        break
25271 
      if fid == 0:
25272 
        if ftype == TType.BOOL:
25273 
          self.success = iprot.readBool();
25274 
        else:
25275 
          iprot.skip(ftype)
25276 
      elif fid == 1:
25277 
        if ftype == TType.STRUCT:
25278 
          self.cex = CatalogServiceException()
25279 
          self.cex.read(iprot)
25280 
        else:
25281 
          iprot.skip(ftype)
25282 
      else:
25283 
        iprot.skip(ftype)
25284 
      iprot.readFieldEnd()
25285 
    iprot.readStructEnd()
25286 
 
25287 
  def write(self, oprot):
25288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25290 
      return
25291 
    oprot.writeStructBegin('addProductFeedSubmit_result')
25292 
    if self.success is not None:
25293 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25294 
      oprot.writeBool(self.success)
25295 
      oprot.writeFieldEnd()
25296 
    if self.cex is not None:
25297 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25298 
      self.cex.write(oprot)
25299 
      oprot.writeFieldEnd()
25300 
    oprot.writeFieldStop()
25301 
    oprot.writeStructEnd()
25302 
 
25303 
  def validate(self):
25304 
    return
25305 
 
25306 
 
25307 
  def __repr__(self):
25308 
    L = ['%s=%r' % (key, value)
25309 
      for key, value in self.__dict__.iteritems()]
25310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25311 
 
25312 
  def __eq__(self, other):
25313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25314 
 
25315 
  def __ne__(self, other):
25316 
    return not (self == other)
25317 
 
25318 
class updateProductFeedSubmit_args:
25319 
  """
25320 
  Attributes:
25321 
   - productFeedSubmit
25322 
  """
25323 
 
25324 
  thrift_spec = (
25325 
    None, # 0
25326 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
25327 
  )
25328 
 
25329 
  def __init__(self, productFeedSubmit=None,):
25330 
    self.productFeedSubmit = productFeedSubmit
25331 
 
25332 
  def read(self, iprot):
25333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25335 
      return
25336 
    iprot.readStructBegin()
25337 
    while True:
25338 
      (fname, ftype, fid) = iprot.readFieldBegin()
25339 
      if ftype == TType.STOP:
25340 
        break
25341 
      if fid == 1:
25342 
        if ftype == TType.STRUCT:
25343 
          self.productFeedSubmit = ProductFeedSubmit()
25344 
          self.productFeedSubmit.read(iprot)
25345 
        else:
25346 
          iprot.skip(ftype)
25347 
      else:
25348 
        iprot.skip(ftype)
25349 
      iprot.readFieldEnd()
25350 
    iprot.readStructEnd()
25351 
 
25352 
  def write(self, oprot):
25353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25355 
      return
25356 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
25357 
    if self.productFeedSubmit is not None:
25358 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
25359 
      self.productFeedSubmit.write(oprot)
25360 
      oprot.writeFieldEnd()
25361 
    oprot.writeFieldStop()
25362 
    oprot.writeStructEnd()
25363 
 
25364 
  def validate(self):
25365 
    return
25366 
 
25367 
 
25368 
  def __repr__(self):
25369 
    L = ['%s=%r' % (key, value)
25370 
      for key, value in self.__dict__.iteritems()]
25371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25372 
 
25373 
  def __eq__(self, other):
25374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25375 
 
25376 
  def __ne__(self, other):
25377 
    return not (self == other)
25378 
 
25379 
class updateProductFeedSubmit_result:
25380 
  """
25381 
  Attributes:
25382 
   - success
25383 
   - cex
25384 
  """
25385 
 
25386 
  thrift_spec = (
25387 
    (0, TType.BOOL, 'success', None, None, ), # 0
25388 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25389 
  )
25390 
 
25391 
  def __init__(self, success=None, cex=None,):
25392 
    self.success = success
25393 
    self.cex = cex
25394 
 
25395 
  def read(self, iprot):
25396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25398 
      return
25399 
    iprot.readStructBegin()
25400 
    while True:
25401 
      (fname, ftype, fid) = iprot.readFieldBegin()
25402 
      if ftype == TType.STOP:
25403 
        break
25404 
      if fid == 0:
25405 
        if ftype == TType.BOOL:
25406 
          self.success = iprot.readBool();
25407 
        else:
25408 
          iprot.skip(ftype)
25409 
      elif fid == 1:
25410 
        if ftype == TType.STRUCT:
25411 
          self.cex = CatalogServiceException()
25412 
          self.cex.read(iprot)
25413 
        else:
25414 
          iprot.skip(ftype)
25415 
      else:
25416 
        iprot.skip(ftype)
25417 
      iprot.readFieldEnd()
25418 
    iprot.readStructEnd()
25419 
 
25420 
  def write(self, oprot):
25421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25423 
      return
25424 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
25425 
    if self.success is not None:
25426 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25427 
      oprot.writeBool(self.success)
25428 
      oprot.writeFieldEnd()
25429 
    if self.cex is not None:
25430 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25431 
      self.cex.write(oprot)
25432 
      oprot.writeFieldEnd()
25433 
    oprot.writeFieldStop()
25434 
    oprot.writeStructEnd()
25435 
 
25436 
  def validate(self):
25437 
    return
25438 
 
25439 
 
25440 
  def __repr__(self):
25441 
    L = ['%s=%r' % (key, value)
25442 
      for key, value in self.__dict__.iteritems()]
25443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25444 
 
25445 
  def __eq__(self, other):
25446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25447 
 
25448 
  def __ne__(self, other):
25449 
    return not (self == other)
25450 
 
25451 
class deleteProductFeedSubmit_args:
25452 
  """
25453 
  Attributes:
25454 
   - catalogItemId
25455 
  """
25456 
 
25457 
  thrift_spec = (
25458 
    None, # 0
25459 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
25460 
  )
25461 
 
25462 
  def __init__(self, catalogItemId=None,):
25463 
    self.catalogItemId = catalogItemId
25464 
 
25465 
  def read(self, iprot):
25466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25468 
      return
25469 
    iprot.readStructBegin()
25470 
    while True:
25471 
      (fname, ftype, fid) = iprot.readFieldBegin()
25472 
      if ftype == TType.STOP:
25473 
        break
25474 
      if fid == 1:
25475 
        if ftype == TType.I64:
25476 
          self.catalogItemId = iprot.readI64();
25477 
        else:
25478 
          iprot.skip(ftype)
25479 
      else:
25480 
        iprot.skip(ftype)
25481 
      iprot.readFieldEnd()
25482 
    iprot.readStructEnd()
25483 
 
25484 
  def write(self, oprot):
25485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25487 
      return
25488 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
25489 
    if self.catalogItemId is not None:
25490 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
25491 
      oprot.writeI64(self.catalogItemId)
25492 
      oprot.writeFieldEnd()
25493 
    oprot.writeFieldStop()
25494 
    oprot.writeStructEnd()
25495 
 
25496 
  def validate(self):
25497 
    return
25498 
 
25499 
 
25500 
  def __repr__(self):
25501 
    L = ['%s=%r' % (key, value)
25502 
      for key, value in self.__dict__.iteritems()]
25503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25504 
 
25505 
  def __eq__(self, other):
25506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25507 
 
25508 
  def __ne__(self, other):
25509 
    return not (self == other)
25510 
 
25511 
class deleteProductFeedSubmit_result:
25512 
  """
25513 
  Attributes:
25514 
   - success
25515 
   - cex
25516 
  """
25517 
 
25518 
  thrift_spec = (
25519 
    (0, TType.BOOL, 'success', None, None, ), # 0
25520 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25521 
  )
25522 
 
25523 
  def __init__(self, success=None, cex=None,):
25524 
    self.success = success
25525 
    self.cex = cex
25526 
 
25527 
  def read(self, iprot):
25528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25530 
      return
25531 
    iprot.readStructBegin()
25532 
    while True:
25533 
      (fname, ftype, fid) = iprot.readFieldBegin()
25534 
      if ftype == TType.STOP:
25535 
        break
25536 
      if fid == 0:
25537 
        if ftype == TType.BOOL:
25538 
          self.success = iprot.readBool();
25539 
        else:
25540 
          iprot.skip(ftype)
25541 
      elif fid == 1:
25542 
        if ftype == TType.STRUCT:
25543 
          self.cex = CatalogServiceException()
25544 
          self.cex.read(iprot)
25545 
        else:
25546 
          iprot.skip(ftype)
25547 
      else:
25548 
        iprot.skip(ftype)
25549 
      iprot.readFieldEnd()
25550 
    iprot.readStructEnd()
25551 
 
25552 
  def write(self, oprot):
25553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25555 
      return
25556 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
25557 
    if self.success is not None:
25558 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25559 
      oprot.writeBool(self.success)
25560 
      oprot.writeFieldEnd()
25561 
    if self.cex is not None:
25562 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25563 
      self.cex.write(oprot)
25564 
      oprot.writeFieldEnd()
25565 
    oprot.writeFieldStop()
25566 
    oprot.writeStructEnd()
25567 
 
25568 
  def validate(self):
25569 
    return
25570 
 
25571 
 
25572 
  def __repr__(self):
25573 
    L = ['%s=%r' % (key, value)
25574 
      for key, value in self.__dict__.iteritems()]
25575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25576 
 
25577 
  def __eq__(self, other):
25578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25579 
 
25580 
  def __ne__(self, other):
25581 
    return not (self == other)
25582 
 
25583 
class getAllProductFeedSubmit_args:
25584 
 
25585 
  thrift_spec = (
25586 
  )
25587 
 
25588 
  def read(self, iprot):
25589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25591 
      return
25592 
    iprot.readStructBegin()
25593 
    while True:
25594 
      (fname, ftype, fid) = iprot.readFieldBegin()
25595 
      if ftype == TType.STOP:
25596 
        break
25597 
      else:
25598 
        iprot.skip(ftype)
25599 
      iprot.readFieldEnd()
25600 
    iprot.readStructEnd()
25601 
 
25602 
  def write(self, oprot):
25603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25605 
      return
25606 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
25607 
    oprot.writeFieldStop()
25608 
    oprot.writeStructEnd()
25609 
 
25610 
  def validate(self):
25611 
    return
25612 
 
25613 
 
25614 
  def __repr__(self):
25615 
    L = ['%s=%r' % (key, value)
25616 
      for key, value in self.__dict__.iteritems()]
25617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25618 
 
25619 
  def __eq__(self, other):
25620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25621 
 
25622 
  def __ne__(self, other):
25623 
    return not (self == other)
25624 
 
25625 
class getAllProductFeedSubmit_result:
25626 
  """
25627 
  Attributes:
25628 
   - success
25629 
   - cex
25630 
  """
25631 
 
25632 
  thrift_spec = (
25633 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
25634 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25635 
  )
25636 
 
25637 
  def __init__(self, success=None, cex=None,):
25638 
    self.success = success
25639 
    self.cex = cex
25640 
 
25641 
  def read(self, iprot):
25642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25644 
      return
25645 
    iprot.readStructBegin()
25646 
    while True:
25647 
      (fname, ftype, fid) = iprot.readFieldBegin()
25648 
      if ftype == TType.STOP:
25649 
        break
25650 
      if fid == 0:
25651 
        if ftype == TType.LIST:
25652 
          self.success = []
25653 
          (_etype551, _size548) = iprot.readListBegin()
25654 
          for _i552 in xrange(_size548):
25655 
            _elem553 = ProductFeedSubmit()
25656 
            _elem553.read(iprot)
25657 
            self.success.append(_elem553)
25658 
          iprot.readListEnd()
25659 
        else:
25660 
          iprot.skip(ftype)
25661 
      elif fid == 1:
25662 
        if ftype == TType.STRUCT:
25663 
          self.cex = CatalogServiceException()
25664 
          self.cex.read(iprot)
25665 
        else:
25666 
          iprot.skip(ftype)
25667 
      else:
25668 
        iprot.skip(ftype)
25669 
      iprot.readFieldEnd()
25670 
    iprot.readStructEnd()
25671 
 
25672 
  def write(self, oprot):
25673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25675 
      return
25676 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
25677 
    if self.success is not None:
25678 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25679 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25680 
      for iter554 in self.success:
25681 
        iter554.write(oprot)
25682 
      oprot.writeListEnd()
25683 
      oprot.writeFieldEnd()
25684 
    if self.cex is not None:
25685 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25686 
      self.cex.write(oprot)
25687 
      oprot.writeFieldEnd()
25688 
    oprot.writeFieldStop()
25689 
    oprot.writeStructEnd()
25690 
 
25691 
  def validate(self):
25692 
    return
25693 
 
25694 
 
25695 
  def __repr__(self):
25696 
    L = ['%s=%r' % (key, value)
25697 
      for key, value in self.__dict__.iteritems()]
25698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25699 
 
25700 
  def __eq__(self, other):
25701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25702 
 
25703 
  def __ne__(self, other):
25704 
    return not (self == other)
9724 kshitij.so 25705 
 
25706 
class getMarketplacedetailsForItem_args:
25707 
  """
25708 
  Attributes:
25709 
   - itemId
25710 
   - sourceId
25711 
  """
25712 
 
25713 
  thrift_spec = (
25714 
    None, # 0
25715 
    (1, TType.I64, 'itemId', None, None, ), # 1
25716 
    (2, TType.I64, 'sourceId', None, None, ), # 2
25717 
  )
25718 
 
25719 
  def __init__(self, itemId=None, sourceId=None,):
25720 
    self.itemId = itemId
25721 
    self.sourceId = sourceId
25722 
 
25723 
  def read(self, iprot):
25724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25726 
      return
25727 
    iprot.readStructBegin()
25728 
    while True:
25729 
      (fname, ftype, fid) = iprot.readFieldBegin()
25730 
      if ftype == TType.STOP:
25731 
        break
25732 
      if fid == 1:
25733 
        if ftype == TType.I64:
25734 
          self.itemId = iprot.readI64();
25735 
        else:
25736 
          iprot.skip(ftype)
25737 
      elif fid == 2:
25738 
        if ftype == TType.I64:
25739 
          self.sourceId = iprot.readI64();
25740 
        else:
25741 
          iprot.skip(ftype)
25742 
      else:
25743 
        iprot.skip(ftype)
25744 
      iprot.readFieldEnd()
25745 
    iprot.readStructEnd()
25746 
 
25747 
  def write(self, oprot):
25748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25750 
      return
25751 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
25752 
    if self.itemId is not None:
25753 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25754 
      oprot.writeI64(self.itemId)
25755 
      oprot.writeFieldEnd()
25756 
    if self.sourceId is not None:
25757 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
25758 
      oprot.writeI64(self.sourceId)
25759 
      oprot.writeFieldEnd()
25760 
    oprot.writeFieldStop()
25761 
    oprot.writeStructEnd()
25762 
 
25763 
  def validate(self):
25764 
    return
25765 
 
25766 
 
25767 
  def __repr__(self):
25768 
    L = ['%s=%r' % (key, value)
25769 
      for key, value in self.__dict__.iteritems()]
25770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25771 
 
25772 
  def __eq__(self, other):
25773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25774 
 
25775 
  def __ne__(self, other):
25776 
    return not (self == other)
25777 
 
25778 
class getMarketplacedetailsForItem_result:
25779 
  """
25780 
  Attributes:
25781 
   - success
25782 
  """
25783 
 
25784 
  thrift_spec = (
25785 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
25786 
  )
25787 
 
25788 
  def __init__(self, success=None,):
25789 
    self.success = success
25790 
 
25791 
  def read(self, iprot):
25792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25794 
      return
25795 
    iprot.readStructBegin()
25796 
    while True:
25797 
      (fname, ftype, fid) = iprot.readFieldBegin()
25798 
      if ftype == TType.STOP:
25799 
        break
25800 
      if fid == 0:
25801 
        if ftype == TType.STRUCT:
25802 
          self.success = MarketplaceItems()
25803 
          self.success.read(iprot)
25804 
        else:
25805 
          iprot.skip(ftype)
25806 
      else:
25807 
        iprot.skip(ftype)
25808 
      iprot.readFieldEnd()
25809 
    iprot.readStructEnd()
25810 
 
25811 
  def write(self, oprot):
25812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25814 
      return
25815 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
25816 
    if self.success is not None:
25817 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25818 
      self.success.write(oprot)
25819 
      oprot.writeFieldEnd()
25820 
    oprot.writeFieldStop()
25821 
    oprot.writeStructEnd()
25822 
 
25823 
  def validate(self):
25824 
    return
25825 
 
25826 
 
25827 
  def __repr__(self):
25828 
    L = ['%s=%r' % (key, value)
25829 
      for key, value in self.__dict__.iteritems()]
25830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25831 
 
25832 
  def __eq__(self, other):
25833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25834 
 
25835 
  def __ne__(self, other):
25836 
    return not (self == other)
25837 
 
25838 
class updateMarketplaceAttributesForItem_args:
25839 
  """
25840 
  Attributes:
25841 
   - marketPlaceItem
25842 
  """
25843 
 
25844 
  thrift_spec = (
25845 
    None, # 0
25846 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
25847 
  )
25848 
 
25849 
  def __init__(self, marketPlaceItem=None,):
25850 
    self.marketPlaceItem = marketPlaceItem
25851 
 
25852 
  def read(self, iprot):
25853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25855 
      return
25856 
    iprot.readStructBegin()
25857 
    while True:
25858 
      (fname, ftype, fid) = iprot.readFieldBegin()
25859 
      if ftype == TType.STOP:
25860 
        break
25861 
      if fid == 1:
25862 
        if ftype == TType.STRUCT:
25863 
          self.marketPlaceItem = MarketplaceItems()
25864 
          self.marketPlaceItem.read(iprot)
25865 
        else:
25866 
          iprot.skip(ftype)
25867 
      else:
25868 
        iprot.skip(ftype)
25869 
      iprot.readFieldEnd()
25870 
    iprot.readStructEnd()
25871 
 
25872 
  def write(self, oprot):
25873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25875 
      return
25876 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
25877 
    if self.marketPlaceItem is not None:
25878 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
25879 
      self.marketPlaceItem.write(oprot)
25880 
      oprot.writeFieldEnd()
25881 
    oprot.writeFieldStop()
25882 
    oprot.writeStructEnd()
25883 
 
25884 
  def validate(self):
25885 
    return
25886 
 
25887 
 
25888 
  def __repr__(self):
25889 
    L = ['%s=%r' % (key, value)
25890 
      for key, value in self.__dict__.iteritems()]
25891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25892 
 
25893 
  def __eq__(self, other):
25894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25895 
 
25896 
  def __ne__(self, other):
25897 
    return not (self == other)
25898 
 
25899 
class updateMarketplaceAttributesForItem_result:
25900 
  """
25901 
  Attributes:
25902 
   - success
25903 
  """
25904 
 
25905 
  thrift_spec = (
25906 
    (0, TType.BOOL, 'success', None, None, ), # 0
25907 
  )
25908 
 
25909 
  def __init__(self, success=None,):
25910 
    self.success = success
25911 
 
25912 
  def read(self, iprot):
25913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25915 
      return
25916 
    iprot.readStructBegin()
25917 
    while True:
25918 
      (fname, ftype, fid) = iprot.readFieldBegin()
25919 
      if ftype == TType.STOP:
25920 
        break
25921 
      if fid == 0:
25922 
        if ftype == TType.BOOL:
25923 
          self.success = iprot.readBool();
25924 
        else:
25925 
          iprot.skip(ftype)
25926 
      else:
25927 
        iprot.skip(ftype)
25928 
      iprot.readFieldEnd()
25929 
    iprot.readStructEnd()
25930 
 
25931 
  def write(self, oprot):
25932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25934 
      return
25935 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
25936 
    if self.success is not None:
25937 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25938 
      oprot.writeBool(self.success)
25939 
      oprot.writeFieldEnd()
25940 
    oprot.writeFieldStop()
25941 
    oprot.writeStructEnd()
25942 
 
25943 
  def validate(self):
25944 
    return
25945 
 
25946 
 
25947 
  def __repr__(self):
25948 
    L = ['%s=%r' % (key, value)
25949 
      for key, value in self.__dict__.iteritems()]
25950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25951 
 
25952 
  def __eq__(self, other):
25953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25954 
 
25955 
  def __ne__(self, other):
25956 
    return not (self == other)
9776 vikram.rag 25957 
 
9779 kshitij.so 25958 
class getCostingForMarketplace_args:
25959 
  """
25960 
  Attributes:
25961 
   - source
25962 
   - item_id
25963 
  """
25964 
 
25965 
  thrift_spec = (
25966 
    None, # 0
25967 
    (1, TType.I64, 'source', None, None, ), # 1
25968 
    (2, TType.I64, 'item_id', None, None, ), # 2
25969 
  )
25970 
 
25971 
  def __init__(self, source=None, item_id=None,):
25972 
    self.source = source
25973 
    self.item_id = item_id
25974 
 
25975 
  def read(self, iprot):
25976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25978 
      return
25979 
    iprot.readStructBegin()
25980 
    while True:
25981 
      (fname, ftype, fid) = iprot.readFieldBegin()
25982 
      if ftype == TType.STOP:
25983 
        break
25984 
      if fid == 1:
25985 
        if ftype == TType.I64:
25986 
          self.source = iprot.readI64();
25987 
        else:
25988 
          iprot.skip(ftype)
25989 
      elif fid == 2:
25990 
        if ftype == TType.I64:
25991 
          self.item_id = iprot.readI64();
25992 
        else:
25993 
          iprot.skip(ftype)
25994 
      else:
25995 
        iprot.skip(ftype)
25996 
      iprot.readFieldEnd()
25997 
    iprot.readStructEnd()
25998 
 
25999 
  def write(self, oprot):
26000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26002 
      return
26003 
    oprot.writeStructBegin('getCostingForMarketplace_args')
26004 
    if self.source is not None:
26005 
      oprot.writeFieldBegin('source', TType.I64, 1)
26006 
      oprot.writeI64(self.source)
26007 
      oprot.writeFieldEnd()
26008 
    if self.item_id is not None:
26009 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
26010 
      oprot.writeI64(self.item_id)
26011 
      oprot.writeFieldEnd()
26012 
    oprot.writeFieldStop()
26013 
    oprot.writeStructEnd()
26014 
 
26015 
  def validate(self):
26016 
    return
26017 
 
26018 
 
26019 
  def __repr__(self):
26020 
    L = ['%s=%r' % (key, value)
26021 
      for key, value in self.__dict__.iteritems()]
26022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26023 
 
26024 
  def __eq__(self, other):
26025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26026 
 
26027 
  def __ne__(self, other):
26028 
    return not (self == other)
26029 
 
26030 
class getCostingForMarketplace_result:
26031 
  """
26032 
  Attributes:
26033 
   - success
26034 
  """
26035 
 
26036 
  thrift_spec = (
26037 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
26038 
  )
26039 
 
26040 
  def __init__(self, success=None,):
26041 
    self.success = success
26042 
 
26043 
  def read(self, iprot):
26044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26046 
      return
26047 
    iprot.readStructBegin()
26048 
    while True:
26049 
      (fname, ftype, fid) = iprot.readFieldBegin()
26050 
      if ftype == TType.STOP:
26051 
        break
26052 
      if fid == 0:
26053 
        if ftype == TType.STRUCT:
26054 
          self.success = MarketplacePercentage()
26055 
          self.success.read(iprot)
26056 
        else:
26057 
          iprot.skip(ftype)
26058 
      else:
26059 
        iprot.skip(ftype)
26060 
      iprot.readFieldEnd()
26061 
    iprot.readStructEnd()
26062 
 
26063 
  def write(self, oprot):
26064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26066 
      return
26067 
    oprot.writeStructBegin('getCostingForMarketplace_result')
26068 
    if self.success is not None:
26069 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26070 
      self.success.write(oprot)
26071 
      oprot.writeFieldEnd()
26072 
    oprot.writeFieldStop()
26073 
    oprot.writeStructEnd()
26074 
 
26075 
  def validate(self):
26076 
    return
26077 
 
26078 
 
26079 
  def __repr__(self):
26080 
    L = ['%s=%r' % (key, value)
26081 
      for key, value in self.__dict__.iteritems()]
26082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26083 
 
26084 
  def __eq__(self, other):
26085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26086 
 
26087 
  def __ne__(self, other):
26088 
    return not (self == other)
26089 
 
9776 vikram.rag 26090 
class getMarketPlaceItemsForPriceUpdate_args:
26091 
  """
26092 
  Attributes:
26093 
   - source
26094 
  """
26095 
 
26096 
  thrift_spec = (
26097 
    None, # 0
26098 
    (1, TType.I64, 'source', None, None, ), # 1
26099 
  )
26100 
 
26101 
  def __init__(self, source=None,):
26102 
    self.source = source
26103 
 
26104 
  def read(self, iprot):
26105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26107 
      return
26108 
    iprot.readStructBegin()
26109 
    while True:
26110 
      (fname, ftype, fid) = iprot.readFieldBegin()
26111 
      if ftype == TType.STOP:
26112 
        break
26113 
      if fid == 1:
26114 
        if ftype == TType.I64:
26115 
          self.source = iprot.readI64();
26116 
        else:
26117 
          iprot.skip(ftype)
26118 
      else:
26119 
        iprot.skip(ftype)
26120 
      iprot.readFieldEnd()
26121 
    iprot.readStructEnd()
26122 
 
26123 
  def write(self, oprot):
26124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26126 
      return
26127 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
26128 
    if self.source is not None:
26129 
      oprot.writeFieldBegin('source', TType.I64, 1)
26130 
      oprot.writeI64(self.source)
26131 
      oprot.writeFieldEnd()
26132 
    oprot.writeFieldStop()
26133 
    oprot.writeStructEnd()
26134 
 
26135 
  def validate(self):
26136 
    return
26137 
 
26138 
 
26139 
  def __repr__(self):
26140 
    L = ['%s=%r' % (key, value)
26141 
      for key, value in self.__dict__.iteritems()]
26142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26143 
 
26144 
  def __eq__(self, other):
26145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26146 
 
26147 
  def __ne__(self, other):
26148 
    return not (self == other)
26149 
 
26150 
class getMarketPlaceItemsForPriceUpdate_result:
26151 
  """
26152 
  Attributes:
26153 
   - success
26154 
  """
26155 
 
26156 
  thrift_spec = (
26157 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
26158 
  )
26159 
 
26160 
  def __init__(self, success=None,):
26161 
    self.success = success
26162 
 
26163 
  def read(self, iprot):
26164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26166 
      return
26167 
    iprot.readStructBegin()
26168 
    while True:
26169 
      (fname, ftype, fid) = iprot.readFieldBegin()
26170 
      if ftype == TType.STOP:
26171 
        break
26172 
      if fid == 0:
26173 
        if ftype == TType.LIST:
26174 
          self.success = []
26175 
          (_etype558, _size555) = iprot.readListBegin()
26176 
          for _i559 in xrange(_size555):
26177 
            _elem560 = MarketPlaceItemPrice()
26178 
            _elem560.read(iprot)
26179 
            self.success.append(_elem560)
26180 
          iprot.readListEnd()
26181 
        else:
26182 
          iprot.skip(ftype)
26183 
      else:
26184 
        iprot.skip(ftype)
26185 
      iprot.readFieldEnd()
26186 
    iprot.readStructEnd()
26187 
 
26188 
  def write(self, oprot):
26189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26191 
      return
26192 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
26193 
    if self.success is not None:
26194 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26195 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26196 
      for iter561 in self.success:
26197 
        iter561.write(oprot)
26198 
      oprot.writeListEnd()
26199 
      oprot.writeFieldEnd()
26200 
    oprot.writeFieldStop()
26201 
    oprot.writeStructEnd()
26202 
 
26203 
  def validate(self):
26204 
    return
26205 
 
26206 
 
26207 
  def __repr__(self):
26208 
    L = ['%s=%r' % (key, value)
26209 
      for key, value in self.__dict__.iteritems()]
26210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26211 
 
26212 
  def __eq__(self, other):
26213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26214 
 
26215 
  def __ne__(self, other):
26216 
    return not (self == other)
26217 
 
26218 
class updateMarketPlacePriceUpdateStatus_args:
26219 
  """
26220 
  Attributes:
26221 
   - skulist
26222 
   - timestamp
9816 kshitij.so 26223 
   - source
9776 vikram.rag 26224 
  """
26225 
 
26226 
  thrift_spec = (
26227 
    None, # 0
26228 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
26229 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 26230 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 26231 
  )
26232 
 
9816 kshitij.so 26233 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 26234 
    self.skulist = skulist
26235 
    self.timestamp = timestamp
9816 kshitij.so 26236 
    self.source = source
9776 vikram.rag 26237 
 
26238 
  def read(self, iprot):
26239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26241 
      return
26242 
    iprot.readStructBegin()
26243 
    while True:
26244 
      (fname, ftype, fid) = iprot.readFieldBegin()
26245 
      if ftype == TType.STOP:
26246 
        break
26247 
      if fid == 1:
26248 
        if ftype == TType.LIST:
26249 
          self.skulist = []
26250 
          (_etype565, _size562) = iprot.readListBegin()
26251 
          for _i566 in xrange(_size562):
26252 
            _elem567 = iprot.readI64();
26253 
            self.skulist.append(_elem567)
26254 
          iprot.readListEnd()
26255 
        else:
26256 
          iprot.skip(ftype)
26257 
      elif fid == 2:
26258 
        if ftype == TType.I64:
26259 
          self.timestamp = iprot.readI64();
26260 
        else:
26261 
          iprot.skip(ftype)
9816 kshitij.so 26262 
      elif fid == 3:
26263 
        if ftype == TType.I64:
26264 
          self.source = iprot.readI64();
26265 
        else:
26266 
          iprot.skip(ftype)
9776 vikram.rag 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('updateMarketPlacePriceUpdateStatus_args')
26277 
    if self.skulist is not None:
26278 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
26279 
      oprot.writeListBegin(TType.I64, len(self.skulist))
26280 
      for iter568 in self.skulist:
26281 
        oprot.writeI64(iter568)
26282 
      oprot.writeListEnd()
26283 
      oprot.writeFieldEnd()
26284 
    if self.timestamp is not None:
26285 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
26286 
      oprot.writeI64(self.timestamp)
26287 
      oprot.writeFieldEnd()
9816 kshitij.so 26288 
    if self.source is not None:
26289 
      oprot.writeFieldBegin('source', TType.I64, 3)
26290 
      oprot.writeI64(self.source)
26291 
      oprot.writeFieldEnd()
9776 vikram.rag 26292 
    oprot.writeFieldStop()
26293 
    oprot.writeStructEnd()
26294 
 
26295 
  def validate(self):
26296 
    return
26297 
 
26298 
 
26299 
  def __repr__(self):
26300 
    L = ['%s=%r' % (key, value)
26301 
      for key, value in self.__dict__.iteritems()]
26302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26303 
 
26304 
  def __eq__(self, other):
26305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26306 
 
26307 
  def __ne__(self, other):
26308 
    return not (self == other)
26309 
 
26310 
class updateMarketPlacePriceUpdateStatus_result:
26311 
 
26312 
  thrift_spec = (
26313 
  )
26314 
 
26315 
  def read(self, iprot):
26316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26318 
      return
26319 
    iprot.readStructBegin()
26320 
    while True:
26321 
      (fname, ftype, fid) = iprot.readFieldBegin()
26322 
      if ftype == TType.STOP:
26323 
        break
26324 
      else:
26325 
        iprot.skip(ftype)
26326 
      iprot.readFieldEnd()
26327 
    iprot.readStructEnd()
26328 
 
26329 
  def write(self, oprot):
26330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26332 
      return
26333 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
26334 
    oprot.writeFieldStop()
26335 
    oprot.writeStructEnd()
26336 
 
26337 
  def validate(self):
26338 
    return
26339 
 
26340 
 
26341 
  def __repr__(self):
26342 
    L = ['%s=%r' % (key, value)
26343 
      for key, value in self.__dict__.iteritems()]
26344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26345 
 
26346 
  def __eq__(self, other):
26347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26348 
 
26349 
  def __ne__(self, other):
26350 
    return not (self == other)
9861 rajveer 26351 
 
26352 
class updateItemHoldInventory_args:
26353 
  """
26354 
  Attributes:
26355 
   - itemHoldMap
26356 
  """
26357 
 
26358 
  thrift_spec = (
26359 
    None, # 0
26360 
    (1, TType.MAP, 'itemHoldMap', (TType.I64,None,TType.I64,None), None, ), # 1
26361 
  )
26362 
 
26363 
  def __init__(self, itemHoldMap=None,):
26364 
    self.itemHoldMap = itemHoldMap
26365 
 
26366 
  def read(self, iprot):
26367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26369 
      return
26370 
    iprot.readStructBegin()
26371 
    while True:
26372 
      (fname, ftype, fid) = iprot.readFieldBegin()
26373 
      if ftype == TType.STOP:
26374 
        break
26375 
      if fid == 1:
26376 
        if ftype == TType.MAP:
26377 
          self.itemHoldMap = {}
26378 
          (_ktype570, _vtype571, _size569 ) = iprot.readMapBegin()
26379 
          for _i573 in xrange(_size569):
26380 
            _key574 = iprot.readI64();
26381 
            _val575 = iprot.readI64();
26382 
            self.itemHoldMap[_key574] = _val575
26383 
          iprot.readMapEnd()
26384 
        else:
26385 
          iprot.skip(ftype)
26386 
      else:
26387 
        iprot.skip(ftype)
26388 
      iprot.readFieldEnd()
26389 
    iprot.readStructEnd()
26390 
 
26391 
  def write(self, oprot):
26392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26394 
      return
26395 
    oprot.writeStructBegin('updateItemHoldInventory_args')
26396 
    if self.itemHoldMap is not None:
26397 
      oprot.writeFieldBegin('itemHoldMap', TType.MAP, 1)
26398 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemHoldMap))
26399 
      for kiter576,viter577 in self.itemHoldMap.items():
26400 
        oprot.writeI64(kiter576)
26401 
        oprot.writeI64(viter577)
26402 
      oprot.writeMapEnd()
26403 
      oprot.writeFieldEnd()
26404 
    oprot.writeFieldStop()
26405 
    oprot.writeStructEnd()
26406 
 
26407 
  def validate(self):
26408 
    return
26409 
 
26410 
 
26411 
  def __repr__(self):
26412 
    L = ['%s=%r' % (key, value)
26413 
      for key, value in self.__dict__.iteritems()]
26414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26415 
 
26416 
  def __eq__(self, other):
26417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26418 
 
26419 
  def __ne__(self, other):
26420 
    return not (self == other)
26421 
 
26422 
class updateItemHoldInventory_result:
26423 
 
26424 
  thrift_spec = (
26425 
  )
26426 
 
26427 
  def read(self, iprot):
26428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26430 
      return
26431 
    iprot.readStructBegin()
26432 
    while True:
26433 
      (fname, ftype, fid) = iprot.readFieldBegin()
26434 
      if ftype == TType.STOP:
26435 
        break
26436 
      else:
26437 
        iprot.skip(ftype)
26438 
      iprot.readFieldEnd()
26439 
    iprot.readStructEnd()
26440 
 
26441 
  def write(self, oprot):
26442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26444 
      return
26445 
    oprot.writeStructBegin('updateItemHoldInventory_result')
26446 
    oprot.writeFieldStop()
26447 
    oprot.writeStructEnd()
26448 
 
26449 
  def validate(self):
26450 
    return
26451 
 
26452 
 
26453 
  def __repr__(self):
26454 
    L = ['%s=%r' % (key, value)
26455 
      for key, value in self.__dict__.iteritems()]
26456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26457 
 
26458 
  def __eq__(self, other):
26459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26460 
 
26461 
  def __ne__(self, other):
26462 
    return not (self == other)
9895 vikram.rag 26463 
 
26464 
class updateNlcAtMarketplaces_args:
26465 
  """
26466 
  Attributes:
26467 
   - item_id
26468 
   - vendor_id
26469 
   - nlc
26470 
  """
26471 
 
26472 
  thrift_spec = None
26473 
  def __init__(self, item_id=None, vendor_id=None, nlc=None,):
26474 
    self.item_id = item_id
26475 
    self.vendor_id = vendor_id
26476 
    self.nlc = nlc
26477 
 
26478 
  def read(self, iprot):
26479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26481 
      return
26482 
    iprot.readStructBegin()
26483 
    while True:
26484 
      (fname, ftype, fid) = iprot.readFieldBegin()
26485 
      if ftype == TType.STOP:
26486 
        break
26487 
      if fid == 1:
26488 
        if ftype == TType.I64:
26489 
          self.item_id = iprot.readI64();
26490 
        else:
26491 
          iprot.skip(ftype)
26492 
      elif fid == 2:
26493 
        if ftype == TType.I64:
26494 
          self.vendor_id = iprot.readI64();
26495 
        else:
26496 
          iprot.skip(ftype)
26497 
      elif fid == -1:
26498 
        if ftype == TType.DOUBLE:
26499 
          self.nlc = iprot.readDouble();
26500 
        else:
26501 
          iprot.skip(ftype)
26502 
      else:
26503 
        iprot.skip(ftype)
26504 
      iprot.readFieldEnd()
26505 
    iprot.readStructEnd()
26506 
 
26507 
  def write(self, oprot):
26508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26510 
      return
26511 
    oprot.writeStructBegin('updateNlcAtMarketplaces_args')
26512 
    if self.nlc is not None:
26513 
      oprot.writeFieldBegin('nlc', TType.DOUBLE, -1)
26514 
      oprot.writeDouble(self.nlc)
26515 
      oprot.writeFieldEnd()
26516 
    if self.item_id is not None:
26517 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26518 
      oprot.writeI64(self.item_id)
26519 
      oprot.writeFieldEnd()
26520 
    if self.vendor_id is not None:
26521 
      oprot.writeFieldBegin('vendor_id', TType.I64, 2)
26522 
      oprot.writeI64(self.vendor_id)
26523 
      oprot.writeFieldEnd()
26524 
    oprot.writeFieldStop()
26525 
    oprot.writeStructEnd()
26526 
 
26527 
  def validate(self):
26528 
    return
26529 
 
26530 
 
26531 
  def __repr__(self):
26532 
    L = ['%s=%r' % (key, value)
26533 
      for key, value in self.__dict__.iteritems()]
26534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26535 
 
26536 
  def __eq__(self, other):
26537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26538 
 
26539 
  def __ne__(self, other):
26540 
    return not (self == other)
26541 
 
26542 
class updateNlcAtMarketplaces_result:
26543 
 
26544 
  thrift_spec = (
26545 
  )
26546 
 
26547 
  def read(self, iprot):
26548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26550 
      return
26551 
    iprot.readStructBegin()
26552 
    while True:
26553 
      (fname, ftype, fid) = iprot.readFieldBegin()
26554 
      if ftype == TType.STOP:
26555 
        break
26556 
      else:
26557 
        iprot.skip(ftype)
26558 
      iprot.readFieldEnd()
26559 
    iprot.readStructEnd()
26560 
 
26561 
  def write(self, oprot):
26562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26564 
      return
26565 
    oprot.writeStructBegin('updateNlcAtMarketplaces_result')
26566 
    oprot.writeFieldStop()
26567 
    oprot.writeStructEnd()
26568 
 
26569 
  def validate(self):
26570 
    return
26571 
 
26572 
 
26573 
  def __repr__(self):
26574 
    L = ['%s=%r' % (key, value)
26575 
      for key, value in self.__dict__.iteritems()]
26576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26577 
 
26578 
  def __eq__(self, other):
26579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26580 
 
26581 
  def __ne__(self, other):
26582 
    return not (self == other)
9945 vikram.rag 26583 
 
26584 
class getAllFlipkartItems_args:
26585 
 
26586 
  thrift_spec = (
26587 
  )
26588 
 
26589 
  def read(self, iprot):
26590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26592 
      return
26593 
    iprot.readStructBegin()
26594 
    while True:
26595 
      (fname, ftype, fid) = iprot.readFieldBegin()
26596 
      if ftype == TType.STOP:
26597 
        break
26598 
      else:
26599 
        iprot.skip(ftype)
26600 
      iprot.readFieldEnd()
26601 
    iprot.readStructEnd()
26602 
 
26603 
  def write(self, oprot):
26604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26606 
      return
26607 
    oprot.writeStructBegin('getAllFlipkartItems_args')
26608 
    oprot.writeFieldStop()
26609 
    oprot.writeStructEnd()
26610 
 
26611 
  def validate(self):
26612 
    return
26613 
 
26614 
 
26615 
  def __repr__(self):
26616 
    L = ['%s=%r' % (key, value)
26617 
      for key, value in self.__dict__.iteritems()]
26618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26619 
 
26620 
  def __eq__(self, other):
26621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26622 
 
26623 
  def __ne__(self, other):
26624 
    return not (self == other)
26625 
 
26626 
class getAllFlipkartItems_result:
26627 
  """
26628 
  Attributes:
26629 
   - success
26630 
  """
26631 
 
26632 
  thrift_spec = (
26633 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
26634 
  )
26635 
 
26636 
  def __init__(self, success=None,):
26637 
    self.success = success
26638 
 
26639 
  def read(self, iprot):
26640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26642 
      return
26643 
    iprot.readStructBegin()
26644 
    while True:
26645 
      (fname, ftype, fid) = iprot.readFieldBegin()
26646 
      if ftype == TType.STOP:
26647 
        break
26648 
      if fid == 0:
26649 
        if ftype == TType.LIST:
26650 
          self.success = []
26651 
          (_etype581, _size578) = iprot.readListBegin()
26652 
          for _i582 in xrange(_size578):
26653 
            _elem583 = FlipkartItem()
26654 
            _elem583.read(iprot)
26655 
            self.success.append(_elem583)
26656 
          iprot.readListEnd()
26657 
        else:
26658 
          iprot.skip(ftype)
26659 
      else:
26660 
        iprot.skip(ftype)
26661 
      iprot.readFieldEnd()
26662 
    iprot.readStructEnd()
26663 
 
26664 
  def write(self, oprot):
26665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26667 
      return
26668 
    oprot.writeStructBegin('getAllFlipkartItems_result')
26669 
    if self.success is not None:
26670 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26671 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26672 
      for iter584 in self.success:
26673 
        iter584.write(oprot)
26674 
      oprot.writeListEnd()
26675 
      oprot.writeFieldEnd()
26676 
    oprot.writeFieldStop()
26677 
    oprot.writeStructEnd()
26678 
 
26679 
  def validate(self):
26680 
    return
26681 
 
26682 
 
26683 
  def __repr__(self):
26684 
    L = ['%s=%r' % (key, value)
26685 
      for key, value in self.__dict__.iteritems()]
26686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26687 
 
26688 
  def __eq__(self, other):
26689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26690 
 
26691 
  def __ne__(self, other):
26692 
    return not (self == other)
10097 kshitij.so 26693 
 
26694 
class addOrUpdateFlipkartItem_args:
26695 
  """
26696 
  Attributes:
26697 
   - flipkartitem
26698 
  """
26699 
 
26700 
  thrift_spec = None
26701 
  def __init__(self, flipkartitem=None,):
26702 
    self.flipkartitem = flipkartitem
26703 
 
26704 
  def read(self, iprot):
26705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26707 
      return
26708 
    iprot.readStructBegin()
26709 
    while True:
26710 
      (fname, ftype, fid) = iprot.readFieldBegin()
26711 
      if ftype == TType.STOP:
26712 
        break
26713 
      if fid == -1:
26714 
        if ftype == TType.STRUCT:
26715 
          self.flipkartitem = FlipkartItem()
26716 
          self.flipkartitem.read(iprot)
26717 
        else:
26718 
          iprot.skip(ftype)
26719 
      else:
26720 
        iprot.skip(ftype)
26721 
      iprot.readFieldEnd()
26722 
    iprot.readStructEnd()
26723 
 
26724 
  def write(self, oprot):
26725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26727 
      return
26728 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_args')
26729 
    if self.flipkartitem is not None:
26730 
      oprot.writeFieldBegin('flipkartitem', TType.STRUCT, -1)
26731 
      self.flipkartitem.write(oprot)
26732 
      oprot.writeFieldEnd()
26733 
    oprot.writeFieldStop()
26734 
    oprot.writeStructEnd()
26735 
 
26736 
  def validate(self):
26737 
    return
26738 
 
26739 
 
26740 
  def __repr__(self):
26741 
    L = ['%s=%r' % (key, value)
26742 
      for key, value in self.__dict__.iteritems()]
26743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26744 
 
26745 
  def __eq__(self, other):
26746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26747 
 
26748 
  def __ne__(self, other):
26749 
    return not (self == other)
26750 
 
26751 
class addOrUpdateFlipkartItem_result:
26752 
  """
26753 
  Attributes:
26754 
   - success
26755 
  """
26756 
 
26757 
  thrift_spec = (
26758 
    (0, TType.BOOL, 'success', None, None, ), # 0
26759 
  )
26760 
 
26761 
  def __init__(self, success=None,):
26762 
    self.success = success
26763 
 
26764 
  def read(self, iprot):
26765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26767 
      return
26768 
    iprot.readStructBegin()
26769 
    while True:
26770 
      (fname, ftype, fid) = iprot.readFieldBegin()
26771 
      if ftype == TType.STOP:
26772 
        break
26773 
      if fid == 0:
26774 
        if ftype == TType.BOOL:
26775 
          self.success = iprot.readBool();
26776 
        else:
26777 
          iprot.skip(ftype)
26778 
      else:
26779 
        iprot.skip(ftype)
26780 
      iprot.readFieldEnd()
26781 
    iprot.readStructEnd()
26782 
 
26783 
  def write(self, oprot):
26784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26786 
      return
26787 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_result')
26788 
    if self.success is not None:
26789 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26790 
      oprot.writeBool(self.success)
26791 
      oprot.writeFieldEnd()
26792 
    oprot.writeFieldStop()
26793 
    oprot.writeStructEnd()
26794 
 
26795 
  def validate(self):
26796 
    return
26797 
 
26798 
 
26799 
  def __repr__(self):
26800 
    L = ['%s=%r' % (key, value)
26801 
      for key, value in self.__dict__.iteritems()]
26802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26803 
 
26804 
  def __eq__(self, other):
26805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26806 
 
26807 
  def __ne__(self, other):
26808 
    return not (self == other)
26809 
 
26810 
class getFlipkartItem_args:
26811 
  """
26812 
  Attributes:
26813 
   - item_id
26814 
  """
26815 
 
26816 
  thrift_spec = (
26817 
    None, # 0
26818 
    (1, TType.I64, 'item_id', None, None, ), # 1
26819 
  )
26820 
 
26821 
  def __init__(self, item_id=None,):
26822 
    self.item_id = item_id
26823 
 
26824 
  def read(self, iprot):
26825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26827 
      return
26828 
    iprot.readStructBegin()
26829 
    while True:
26830 
      (fname, ftype, fid) = iprot.readFieldBegin()
26831 
      if ftype == TType.STOP:
26832 
        break
26833 
      if fid == 1:
26834 
        if ftype == TType.I64:
26835 
          self.item_id = iprot.readI64();
26836 
        else:
26837 
          iprot.skip(ftype)
26838 
      else:
26839 
        iprot.skip(ftype)
26840 
      iprot.readFieldEnd()
26841 
    iprot.readStructEnd()
26842 
 
26843 
  def write(self, oprot):
26844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26846 
      return
26847 
    oprot.writeStructBegin('getFlipkartItem_args')
26848 
    if self.item_id is not None:
26849 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26850 
      oprot.writeI64(self.item_id)
26851 
      oprot.writeFieldEnd()
26852 
    oprot.writeFieldStop()
26853 
    oprot.writeStructEnd()
26854 
 
26855 
  def validate(self):
26856 
    return
26857 
 
26858 
 
26859 
  def __repr__(self):
26860 
    L = ['%s=%r' % (key, value)
26861 
      for key, value in self.__dict__.iteritems()]
26862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26863 
 
26864 
  def __eq__(self, other):
26865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26866 
 
26867 
  def __ne__(self, other):
26868 
    return not (self == other)
26869 
 
26870 
class getFlipkartItem_result:
26871 
  """
26872 
  Attributes:
26873 
   - success
26874 
  """
26875 
 
26876 
  thrift_spec = (
26877 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
26878 
  )
26879 
 
26880 
  def __init__(self, success=None,):
26881 
    self.success = success
26882 
 
26883 
  def read(self, iprot):
26884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26886 
      return
26887 
    iprot.readStructBegin()
26888 
    while True:
26889 
      (fname, ftype, fid) = iprot.readFieldBegin()
26890 
      if ftype == TType.STOP:
26891 
        break
26892 
      if fid == 0:
26893 
        if ftype == TType.STRUCT:
26894 
          self.success = FlipkartItem()
26895 
          self.success.read(iprot)
26896 
        else:
26897 
          iprot.skip(ftype)
26898 
      else:
26899 
        iprot.skip(ftype)
26900 
      iprot.readFieldEnd()
26901 
    iprot.readStructEnd()
26902 
 
26903 
  def write(self, oprot):
26904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26906 
      return
26907 
    oprot.writeStructBegin('getFlipkartItem_result')
26908 
    if self.success is not None:
26909 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26910 
      self.success.write(oprot)
26911 
      oprot.writeFieldEnd()
26912 
    oprot.writeFieldStop()
26913 
    oprot.writeStructEnd()
26914 
 
26915 
  def validate(self):
26916 
    return
26917 
 
26918 
 
26919 
  def __repr__(self):
26920 
    L = ['%s=%r' % (key, value)
26921 
      for key, value in self.__dict__.iteritems()]
26922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26923 
 
26924 
  def __eq__(self, other):
26925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26926 
 
26927 
  def __ne__(self, other):
26928 
    return not (self == other)
26929 
 
26930 
class getFlipkartItemDetails_args:
26931 
  """
26932 
  Attributes:
26933 
   - item_id
26934 
  """
26935 
 
26936 
  thrift_spec = (
26937 
    None, # 0
26938 
    (1, TType.I64, 'item_id', None, None, ), # 1
26939 
  )
26940 
 
26941 
  def __init__(self, item_id=None,):
26942 
    self.item_id = item_id
26943 
 
26944 
  def read(self, iprot):
26945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26947 
      return
26948 
    iprot.readStructBegin()
26949 
    while True:
26950 
      (fname, ftype, fid) = iprot.readFieldBegin()
26951 
      if ftype == TType.STOP:
26952 
        break
26953 
      if fid == 1:
26954 
        if ftype == TType.I64:
26955 
          self.item_id = iprot.readI64();
26956 
        else:
26957 
          iprot.skip(ftype)
26958 
      else:
26959 
        iprot.skip(ftype)
26960 
      iprot.readFieldEnd()
26961 
    iprot.readStructEnd()
26962 
 
26963 
  def write(self, oprot):
26964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26966 
      return
26967 
    oprot.writeStructBegin('getFlipkartItemDetails_args')
26968 
    if self.item_id is not None:
26969 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26970 
      oprot.writeI64(self.item_id)
26971 
      oprot.writeFieldEnd()
26972 
    oprot.writeFieldStop()
26973 
    oprot.writeStructEnd()
26974 
 
26975 
  def validate(self):
26976 
    return
26977 
 
26978 
 
26979 
  def __repr__(self):
26980 
    L = ['%s=%r' % (key, value)
26981 
      for key, value in self.__dict__.iteritems()]
26982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26983 
 
26984 
  def __eq__(self, other):
26985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26986 
 
26987 
  def __ne__(self, other):
26988 
    return not (self == other)
26989 
 
26990 
class getFlipkartItemDetails_result:
26991 
  """
26992 
  Attributes:
26993 
   - success
26994 
  """
26995 
 
26996 
  thrift_spec = (
26997 
    (0, TType.STRUCT, 'success', (FlipkartItemDetails, FlipkartItemDetails.thrift_spec), None, ), # 0
26998 
  )
26999 
 
27000 
  def __init__(self, success=None,):
27001 
    self.success = success
27002 
 
27003 
  def read(self, iprot):
27004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27006 
      return
27007 
    iprot.readStructBegin()
27008 
    while True:
27009 
      (fname, ftype, fid) = iprot.readFieldBegin()
27010 
      if ftype == TType.STOP:
27011 
        break
27012 
      if fid == 0:
27013 
        if ftype == TType.STRUCT:
27014 
          self.success = FlipkartItemDetails()
27015 
          self.success.read(iprot)
27016 
        else:
27017 
          iprot.skip(ftype)
27018 
      else:
27019 
        iprot.skip(ftype)
27020 
      iprot.readFieldEnd()
27021 
    iprot.readStructEnd()
27022 
 
27023 
  def write(self, oprot):
27024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27026 
      return
27027 
    oprot.writeStructBegin('getFlipkartItemDetails_result')
27028 
    if self.success is not None:
27029 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27030 
      self.success.write(oprot)
27031 
      oprot.writeFieldEnd()
27032 
    oprot.writeFieldStop()
27033 
    oprot.writeStructEnd()
27034 
 
27035 
  def validate(self):
27036 
    return
27037 
 
27038 
 
27039 
  def __repr__(self):
27040 
    L = ['%s=%r' % (key, value)
27041 
      for key, value in self.__dict__.iteritems()]
27042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27043 
 
27044 
  def __eq__(self, other):
27045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27046 
 
27047 
  def __ne__(self, other):
27048 
    return not (self == other)
27049 
 
27050 
class getFlipkartItems_args:
27051 
  """
27052 
  Attributes:
27053 
   - offset
27054 
   - limit
27055 
  """
27056 
 
27057 
  thrift_spec = (
27058 
    None, # 0
27059 
    (1, TType.I64, 'offset', None, None, ), # 1
27060 
    (2, TType.I64, 'limit', None, None, ), # 2
27061 
  )
27062 
 
27063 
  def __init__(self, offset=None, limit=None,):
27064 
    self.offset = offset
27065 
    self.limit = limit
27066 
 
27067 
  def read(self, iprot):
27068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27070 
      return
27071 
    iprot.readStructBegin()
27072 
    while True:
27073 
      (fname, ftype, fid) = iprot.readFieldBegin()
27074 
      if ftype == TType.STOP:
27075 
        break
27076 
      if fid == 1:
27077 
        if ftype == TType.I64:
27078 
          self.offset = iprot.readI64();
27079 
        else:
27080 
          iprot.skip(ftype)
27081 
      elif fid == 2:
27082 
        if ftype == TType.I64:
27083 
          self.limit = iprot.readI64();
27084 
        else:
27085 
          iprot.skip(ftype)
27086 
      else:
27087 
        iprot.skip(ftype)
27088 
      iprot.readFieldEnd()
27089 
    iprot.readStructEnd()
27090 
 
27091 
  def write(self, oprot):
27092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27094 
      return
27095 
    oprot.writeStructBegin('getFlipkartItems_args')
27096 
    if self.offset is not None:
27097 
      oprot.writeFieldBegin('offset', TType.I64, 1)
27098 
      oprot.writeI64(self.offset)
27099 
      oprot.writeFieldEnd()
27100 
    if self.limit is not None:
27101 
      oprot.writeFieldBegin('limit', TType.I64, 2)
27102 
      oprot.writeI64(self.limit)
27103 
      oprot.writeFieldEnd()
27104 
    oprot.writeFieldStop()
27105 
    oprot.writeStructEnd()
27106 
 
27107 
  def validate(self):
27108 
    return
27109 
 
27110 
 
27111 
  def __repr__(self):
27112 
    L = ['%s=%r' % (key, value)
27113 
      for key, value in self.__dict__.iteritems()]
27114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27115 
 
27116 
  def __eq__(self, other):
27117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27118 
 
27119 
  def __ne__(self, other):
27120 
    return not (self == other)
27121 
 
27122 
class getFlipkartItems_result:
27123 
  """
27124 
  Attributes:
27125 
   - success
27126 
  """
27127 
 
27128 
  thrift_spec = (
27129 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27130 
  )
27131 
 
27132 
  def __init__(self, success=None,):
27133 
    self.success = success
27134 
 
27135 
  def read(self, iprot):
27136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27138 
      return
27139 
    iprot.readStructBegin()
27140 
    while True:
27141 
      (fname, ftype, fid) = iprot.readFieldBegin()
27142 
      if ftype == TType.STOP:
27143 
        break
27144 
      if fid == 0:
27145 
        if ftype == TType.LIST:
27146 
          self.success = []
27147 
          (_etype588, _size585) = iprot.readListBegin()
27148 
          for _i589 in xrange(_size585):
27149 
            _elem590 = FlipkartItemDetails()
27150 
            _elem590.read(iprot)
27151 
            self.success.append(_elem590)
27152 
          iprot.readListEnd()
27153 
        else:
27154 
          iprot.skip(ftype)
27155 
      else:
27156 
        iprot.skip(ftype)
27157 
      iprot.readFieldEnd()
27158 
    iprot.readStructEnd()
27159 
 
27160 
  def write(self, oprot):
27161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27163 
      return
27164 
    oprot.writeStructBegin('getFlipkartItems_result')
27165 
    if self.success is not None:
27166 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27167 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27168 
      for iter591 in self.success:
27169 
        iter591.write(oprot)
27170 
      oprot.writeListEnd()
27171 
      oprot.writeFieldEnd()
27172 
    oprot.writeFieldStop()
27173 
    oprot.writeStructEnd()
27174 
 
27175 
  def validate(self):
27176 
    return
27177 
 
27178 
 
27179 
  def __repr__(self):
27180 
    L = ['%s=%r' % (key, value)
27181 
      for key, value in self.__dict__.iteritems()]
27182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27183 
 
27184 
  def __eq__(self, other):
27185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27186 
 
27187 
  def __ne__(self, other):
27188 
    return not (self == other)
27189 
 
27190 
class searchFlipkartItems_args:
27191 
  """
27192 
  Attributes:
27193 
   - searchTerm
27194 
   - offset
27195 
   - limit
27196 
  """
27197 
 
27198 
  thrift_spec = (
27199 
    None, # 0
27200 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
27201 
    (2, TType.I64, 'offset', None, None, ), # 2
27202 
    (3, TType.I64, 'limit', None, None, ), # 3
27203 
  )
27204 
 
27205 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
27206 
    self.searchTerm = searchTerm
27207 
    self.offset = offset
27208 
    self.limit = limit
27209 
 
27210 
  def read(self, iprot):
27211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27213 
      return
27214 
    iprot.readStructBegin()
27215 
    while True:
27216 
      (fname, ftype, fid) = iprot.readFieldBegin()
27217 
      if ftype == TType.STOP:
27218 
        break
27219 
      if fid == 1:
27220 
        if ftype == TType.LIST:
27221 
          self.searchTerm = []
27222 
          (_etype595, _size592) = iprot.readListBegin()
27223 
          for _i596 in xrange(_size592):
27224 
            _elem597 = iprot.readString();
27225 
            self.searchTerm.append(_elem597)
27226 
          iprot.readListEnd()
27227 
        else:
27228 
          iprot.skip(ftype)
27229 
      elif fid == 2:
27230 
        if ftype == TType.I64:
27231 
          self.offset = iprot.readI64();
27232 
        else:
27233 
          iprot.skip(ftype)
27234 
      elif fid == 3:
27235 
        if ftype == TType.I64:
27236 
          self.limit = iprot.readI64();
27237 
        else:
27238 
          iprot.skip(ftype)
27239 
      else:
27240 
        iprot.skip(ftype)
27241 
      iprot.readFieldEnd()
27242 
    iprot.readStructEnd()
27243 
 
27244 
  def write(self, oprot):
27245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27247 
      return
27248 
    oprot.writeStructBegin('searchFlipkartItems_args')
27249 
    if self.searchTerm is not None:
27250 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
27251 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
27252 
      for iter598 in self.searchTerm:
27253 
        oprot.writeString(iter598)
27254 
      oprot.writeListEnd()
27255 
      oprot.writeFieldEnd()
27256 
    if self.offset is not None:
27257 
      oprot.writeFieldBegin('offset', TType.I64, 2)
27258 
      oprot.writeI64(self.offset)
27259 
      oprot.writeFieldEnd()
27260 
    if self.limit is not None:
27261 
      oprot.writeFieldBegin('limit', TType.I64, 3)
27262 
      oprot.writeI64(self.limit)
27263 
      oprot.writeFieldEnd()
27264 
    oprot.writeFieldStop()
27265 
    oprot.writeStructEnd()
27266 
 
27267 
  def validate(self):
27268 
    return
27269 
 
27270 
 
27271 
  def __repr__(self):
27272 
    L = ['%s=%r' % (key, value)
27273 
      for key, value in self.__dict__.iteritems()]
27274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27275 
 
27276 
  def __eq__(self, other):
27277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27278 
 
27279 
  def __ne__(self, other):
27280 
    return not (self == other)
27281 
 
27282 
class searchFlipkartItems_result:
27283 
  """
27284 
  Attributes:
27285 
   - success
27286 
  """
27287 
 
27288 
  thrift_spec = (
27289 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27290 
  )
27291 
 
27292 
  def __init__(self, success=None,):
27293 
    self.success = success
27294 
 
27295 
  def read(self, iprot):
27296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27298 
      return
27299 
    iprot.readStructBegin()
27300 
    while True:
27301 
      (fname, ftype, fid) = iprot.readFieldBegin()
27302 
      if ftype == TType.STOP:
27303 
        break
27304 
      if fid == 0:
27305 
        if ftype == TType.LIST:
27306 
          self.success = []
27307 
          (_etype602, _size599) = iprot.readListBegin()
27308 
          for _i603 in xrange(_size599):
27309 
            _elem604 = FlipkartItemDetails()
27310 
            _elem604.read(iprot)
27311 
            self.success.append(_elem604)
27312 
          iprot.readListEnd()
27313 
        else:
27314 
          iprot.skip(ftype)
27315 
      else:
27316 
        iprot.skip(ftype)
27317 
      iprot.readFieldEnd()
27318 
    iprot.readStructEnd()
27319 
 
27320 
  def write(self, oprot):
27321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27323 
      return
27324 
    oprot.writeStructBegin('searchFlipkartItems_result')
27325 
    if self.success is not None:
27326 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27327 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27328 
      for iter605 in self.success:
27329 
        iter605.write(oprot)
27330 
      oprot.writeListEnd()
27331 
      oprot.writeFieldEnd()
27332 
    oprot.writeFieldStop()
27333 
    oprot.writeStructEnd()
27334 
 
27335 
  def validate(self):
27336 
    return
27337 
 
27338 
 
27339 
  def __repr__(self):
27340 
    L = ['%s=%r' % (key, value)
27341 
      for key, value in self.__dict__.iteritems()]
27342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27343 
 
27344 
  def __eq__(self, other):
27345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27346 
 
27347 
  def __ne__(self, other):
27348 
    return not (self == other)
27349 
 
27350 
class getCountForFlipkartItems_args:
27351 
 
27352 
  thrift_spec = (
27353 
  )
27354 
 
27355 
  def read(self, iprot):
27356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27358 
      return
27359 
    iprot.readStructBegin()
27360 
    while True:
27361 
      (fname, ftype, fid) = iprot.readFieldBegin()
27362 
      if ftype == TType.STOP:
27363 
        break
27364 
      else:
27365 
        iprot.skip(ftype)
27366 
      iprot.readFieldEnd()
27367 
    iprot.readStructEnd()
27368 
 
27369 
  def write(self, oprot):
27370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27372 
      return
27373 
    oprot.writeStructBegin('getCountForFlipkartItems_args')
27374 
    oprot.writeFieldStop()
27375 
    oprot.writeStructEnd()
27376 
 
27377 
  def validate(self):
27378 
    return
27379 
 
27380 
 
27381 
  def __repr__(self):
27382 
    L = ['%s=%r' % (key, value)
27383 
      for key, value in self.__dict__.iteritems()]
27384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27385 
 
27386 
  def __eq__(self, other):
27387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27388 
 
27389 
  def __ne__(self, other):
27390 
    return not (self == other)
27391 
 
27392 
class getCountForFlipkartItems_result:
27393 
  """
27394 
  Attributes:
27395 
   - success
27396 
  """
27397 
 
27398 
  thrift_spec = (
27399 
    (0, TType.I64, 'success', None, None, ), # 0
27400 
  )
27401 
 
27402 
  def __init__(self, success=None,):
27403 
    self.success = success
27404 
 
27405 
  def read(self, iprot):
27406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27408 
      return
27409 
    iprot.readStructBegin()
27410 
    while True:
27411 
      (fname, ftype, fid) = iprot.readFieldBegin()
27412 
      if ftype == TType.STOP:
27413 
        break
27414 
      if fid == 0:
27415 
        if ftype == TType.I64:
27416 
          self.success = iprot.readI64();
27417 
        else:
27418 
          iprot.skip(ftype)
27419 
      else:
27420 
        iprot.skip(ftype)
27421 
      iprot.readFieldEnd()
27422 
    iprot.readStructEnd()
27423 
 
27424 
  def write(self, oprot):
27425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27427 
      return
27428 
    oprot.writeStructBegin('getCountForFlipkartItems_result')
27429 
    if self.success is not None:
27430 
      oprot.writeFieldBegin('success', TType.I64, 0)
27431 
      oprot.writeI64(self.success)
27432 
      oprot.writeFieldEnd()
27433 
    oprot.writeFieldStop()
27434 
    oprot.writeStructEnd()
27435 
 
27436 
  def validate(self):
27437 
    return
27438 
 
27439 
 
27440 
  def __repr__(self):
27441 
    L = ['%s=%r' % (key, value)
27442 
      for key, value in self.__dict__.iteritems()]
27443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27444 
 
27445 
  def __eq__(self, other):
27446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27447 
 
27448 
  def __ne__(self, other):
27449 
    return not (self == other)
27450 
 
27451 
class getFlipkartSearchResultCount_args:
27452 
  """
27453 
  Attributes:
27454 
   - searchTerm
27455 
  """
27456 
 
27457 
  thrift_spec = (
27458 
    None, # 0
27459 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
27460 
  )
27461 
 
27462 
  def __init__(self, searchTerm=None,):
27463 
    self.searchTerm = searchTerm
27464 
 
27465 
  def read(self, iprot):
27466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27468 
      return
27469 
    iprot.readStructBegin()
27470 
    while True:
27471 
      (fname, ftype, fid) = iprot.readFieldBegin()
27472 
      if ftype == TType.STOP:
27473 
        break
27474 
      if fid == 1:
27475 
        if ftype == TType.LIST:
27476 
          self.searchTerm = []
27477 
          (_etype609, _size606) = iprot.readListBegin()
27478 
          for _i610 in xrange(_size606):
27479 
            _elem611 = iprot.readString();
27480 
            self.searchTerm.append(_elem611)
27481 
          iprot.readListEnd()
27482 
        else:
27483 
          iprot.skip(ftype)
27484 
      else:
27485 
        iprot.skip(ftype)
27486 
      iprot.readFieldEnd()
27487 
    iprot.readStructEnd()
27488 
 
27489 
  def write(self, oprot):
27490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27492 
      return
27493 
    oprot.writeStructBegin('getFlipkartSearchResultCount_args')
27494 
    if self.searchTerm is not None:
27495 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
27496 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
27497 
      for iter612 in self.searchTerm:
27498 
        oprot.writeString(iter612)
27499 
      oprot.writeListEnd()
27500 
      oprot.writeFieldEnd()
27501 
    oprot.writeFieldStop()
27502 
    oprot.writeStructEnd()
27503 
 
27504 
  def validate(self):
27505 
    return
27506 
 
27507 
 
27508 
  def __repr__(self):
27509 
    L = ['%s=%r' % (key, value)
27510 
      for key, value in self.__dict__.iteritems()]
27511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27512 
 
27513 
  def __eq__(self, other):
27514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27515 
 
27516 
  def __ne__(self, other):
27517 
    return not (self == other)
27518 
 
27519 
class getFlipkartSearchResultCount_result:
27520 
  """
27521 
  Attributes:
27522 
   - success
27523 
  """
27524 
 
27525 
  thrift_spec = (
27526 
    (0, TType.I64, 'success', None, None, ), # 0
27527 
  )
27528 
 
27529 
  def __init__(self, success=None,):
27530 
    self.success = success
27531 
 
27532 
  def read(self, iprot):
27533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27535 
      return
27536 
    iprot.readStructBegin()
27537 
    while True:
27538 
      (fname, ftype, fid) = iprot.readFieldBegin()
27539 
      if ftype == TType.STOP:
27540 
        break
27541 
      if fid == 0:
27542 
        if ftype == TType.I64:
27543 
          self.success = iprot.readI64();
27544 
        else:
27545 
          iprot.skip(ftype)
27546 
      else:
27547 
        iprot.skip(ftype)
27548 
      iprot.readFieldEnd()
27549 
    iprot.readStructEnd()
27550 
 
27551 
  def write(self, oprot):
27552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27554 
      return
27555 
    oprot.writeStructBegin('getFlipkartSearchResultCount_result')
27556 
    if self.success is not None:
27557 
      oprot.writeFieldBegin('success', TType.I64, 0)
27558 
      oprot.writeI64(self.success)
27559 
      oprot.writeFieldEnd()
27560 
    oprot.writeFieldStop()
27561 
    oprot.writeStructEnd()
27562 
 
27563 
  def validate(self):
27564 
    return
27565 
 
27566 
 
27567 
  def __repr__(self):
27568 
    L = ['%s=%r' % (key, value)
27569 
      for key, value in self.__dict__.iteritems()]
27570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27571 
 
27572 
  def __eq__(self, other):
27573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27574 
 
27575 
  def __ne__(self, other):
27576 
    return not (self == other)
27577 
 
27578 
class getAllFkItems_args:
27579 
 
27580 
  thrift_spec = (
27581 
  )
27582 
 
27583 
  def read(self, iprot):
27584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27586 
      return
27587 
    iprot.readStructBegin()
27588 
    while True:
27589 
      (fname, ftype, fid) = iprot.readFieldBegin()
27590 
      if ftype == TType.STOP:
27591 
        break
27592 
      else:
27593 
        iprot.skip(ftype)
27594 
      iprot.readFieldEnd()
27595 
    iprot.readStructEnd()
27596 
 
27597 
  def write(self, oprot):
27598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27600 
      return
27601 
    oprot.writeStructBegin('getAllFkItems_args')
27602 
    oprot.writeFieldStop()
27603 
    oprot.writeStructEnd()
27604 
 
27605 
  def validate(self):
27606 
    return
27607 
 
27608 
 
27609 
  def __repr__(self):
27610 
    L = ['%s=%r' % (key, value)
27611 
      for key, value in self.__dict__.iteritems()]
27612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27613 
 
27614 
  def __eq__(self, other):
27615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27616 
 
27617 
  def __ne__(self, other):
27618 
    return not (self == other)
27619 
 
27620 
class getAllFkItems_result:
27621 
  """
27622 
  Attributes:
27623 
   - success
27624 
  """
27625 
 
27626 
  thrift_spec = (
27627 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27628 
  )
27629 
 
27630 
  def __init__(self, success=None,):
27631 
    self.success = success
27632 
 
27633 
  def read(self, iprot):
27634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27636 
      return
27637 
    iprot.readStructBegin()
27638 
    while True:
27639 
      (fname, ftype, fid) = iprot.readFieldBegin()
27640 
      if ftype == TType.STOP:
27641 
        break
27642 
      if fid == 0:
27643 
        if ftype == TType.LIST:
27644 
          self.success = []
27645 
          (_etype616, _size613) = iprot.readListBegin()
27646 
          for _i617 in xrange(_size613):
27647 
            _elem618 = FlipkartItemDetails()
27648 
            _elem618.read(iprot)
27649 
            self.success.append(_elem618)
27650 
          iprot.readListEnd()
27651 
        else:
27652 
          iprot.skip(ftype)
27653 
      else:
27654 
        iprot.skip(ftype)
27655 
      iprot.readFieldEnd()
27656 
    iprot.readStructEnd()
27657 
 
27658 
  def write(self, oprot):
27659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27661 
      return
27662 
    oprot.writeStructBegin('getAllFkItems_result')
27663 
    if self.success is not None:
27664 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27665 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27666 
      for iter619 in self.success:
27667 
        iter619.write(oprot)
27668 
      oprot.writeListEnd()
27669 
      oprot.writeFieldEnd()
27670 
    oprot.writeFieldStop()
27671 
    oprot.writeStructEnd()
27672 
 
27673 
  def validate(self):
27674 
    return
27675 
 
27676 
 
27677 
  def __repr__(self):
27678 
    L = ['%s=%r' % (key, value)
27679 
      for key, value in self.__dict__.iteritems()]
27680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27681 
 
27682 
  def __eq__(self, other):
27683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27684 
 
27685 
  def __ne__(self, other):
27686 
    return not (self == other)
10140 vikram.rag 27687 
 
27688 
class getFlipkartItemBySkyAtFlipkart_args:
27689 
  """
27690 
  Attributes:
27691 
   - sku
27692 
  """
27693 
 
11531 vikram.rag 27694 
  thrift_spec = None
10140 vikram.rag 27695 
  def __init__(self, sku=None,):
27696 
    self.sku = sku
27697 
 
27698 
  def read(self, iprot):
27699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27701 
      return
27702 
    iprot.readStructBegin()
27703 
    while True:
27704 
      (fname, ftype, fid) = iprot.readFieldBegin()
27705 
      if ftype == TType.STOP:
27706 
        break
11531 vikram.rag 27707 
      if fid == -1:
10140 vikram.rag 27708 
        if ftype == TType.STRING:
27709 
          self.sku = iprot.readString();
27710 
        else:
27711 
          iprot.skip(ftype)
27712 
      else:
27713 
        iprot.skip(ftype)
27714 
      iprot.readFieldEnd()
27715 
    iprot.readStructEnd()
27716 
 
27717 
  def write(self, oprot):
27718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27720 
      return
27721 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_args')
27722 
    if self.sku is not None:
11531 vikram.rag 27723 
      oprot.writeFieldBegin('sku', TType.STRING, -1)
10140 vikram.rag 27724 
      oprot.writeString(self.sku)
27725 
      oprot.writeFieldEnd()
27726 
    oprot.writeFieldStop()
27727 
    oprot.writeStructEnd()
27728 
 
27729 
  def validate(self):
27730 
    return
27731 
 
27732 
 
27733 
  def __repr__(self):
27734 
    L = ['%s=%r' % (key, value)
27735 
      for key, value in self.__dict__.iteritems()]
27736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27737 
 
27738 
  def __eq__(self, other):
27739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27740 
 
27741 
  def __ne__(self, other):
27742 
    return not (self == other)
27743 
 
27744 
class getFlipkartItemBySkyAtFlipkart_result:
27745 
  """
27746 
  Attributes:
27747 
   - success
27748 
  """
27749 
 
27750 
  thrift_spec = (
27751 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
27752 
  )
27753 
 
27754 
  def __init__(self, success=None,):
27755 
    self.success = success
27756 
 
27757 
  def read(self, iprot):
27758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27760 
      return
27761 
    iprot.readStructBegin()
27762 
    while True:
27763 
      (fname, ftype, fid) = iprot.readFieldBegin()
27764 
      if ftype == TType.STOP:
27765 
        break
27766 
      if fid == 0:
27767 
        if ftype == TType.STRUCT:
27768 
          self.success = FlipkartItem()
27769 
          self.success.read(iprot)
27770 
        else:
27771 
          iprot.skip(ftype)
27772 
      else:
27773 
        iprot.skip(ftype)
27774 
      iprot.readFieldEnd()
27775 
    iprot.readStructEnd()
27776 
 
27777 
  def write(self, oprot):
27778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27780 
      return
27781 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_result')
27782 
    if self.success is not None:
27783 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27784 
      self.success.write(oprot)
27785 
      oprot.writeFieldEnd()
27786 
    oprot.writeFieldStop()
27787 
    oprot.writeStructEnd()
27788 
 
27789 
  def validate(self):
27790 
    return
27791 
 
27792 
 
27793 
  def __repr__(self):
27794 
    L = ['%s=%r' % (key, value)
27795 
      for key, value in self.__dict__.iteritems()]
27796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27797 
 
27798 
  def __eq__(self, other):
27799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27800 
 
27801 
  def __ne__(self, other):
27802 
    return not (self == other)
10909 vikram.rag 27803 
 
11015 kshitij.so 27804 
class getMarketplaceHistory_args:
27805 
  """
27806 
  Attributes:
27807 
   - source
27808 
   - offset
27809 
   - itemId
27810 
  """
10909 vikram.rag 27811 
 
27812 
  thrift_spec = (
11015 kshitij.so 27813 
    None, # 0
27814 
    (1, TType.I64, 'source', None, None, ), # 1
27815 
    (2, TType.I64, 'offset', None, None, ), # 2
27816 
    (3, TType.I64, 'itemId', None, None, ), # 3
10909 vikram.rag 27817 
  )
27818 
 
11015 kshitij.so 27819 
  def __init__(self, source=None, offset=None, itemId=None,):
27820 
    self.source = source
27821 
    self.offset = offset
27822 
    self.itemId = itemId
27823 
 
10909 vikram.rag 27824 
  def read(self, iprot):
27825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27827 
      return
27828 
    iprot.readStructBegin()
27829 
    while True:
27830 
      (fname, ftype, fid) = iprot.readFieldBegin()
27831 
      if ftype == TType.STOP:
27832 
        break
11015 kshitij.so 27833 
      if fid == 1:
27834 
        if ftype == TType.I64:
27835 
          self.source = iprot.readI64();
27836 
        else:
27837 
          iprot.skip(ftype)
27838 
      elif fid == 2:
27839 
        if ftype == TType.I64:
27840 
          self.offset = iprot.readI64();
27841 
        else:
27842 
          iprot.skip(ftype)
27843 
      elif fid == 3:
27844 
        if ftype == TType.I64:
27845 
          self.itemId = iprot.readI64();
27846 
        else:
27847 
          iprot.skip(ftype)
10909 vikram.rag 27848 
      else:
27849 
        iprot.skip(ftype)
27850 
      iprot.readFieldEnd()
27851 
    iprot.readStructEnd()
27852 
 
27853 
  def write(self, oprot):
27854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27856 
      return
11015 kshitij.so 27857 
    oprot.writeStructBegin('getMarketplaceHistory_args')
27858 
    if self.source is not None:
27859 
      oprot.writeFieldBegin('source', TType.I64, 1)
27860 
      oprot.writeI64(self.source)
27861 
      oprot.writeFieldEnd()
27862 
    if self.offset is not None:
27863 
      oprot.writeFieldBegin('offset', TType.I64, 2)
27864 
      oprot.writeI64(self.offset)
27865 
      oprot.writeFieldEnd()
27866 
    if self.itemId is not None:
27867 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
27868 
      oprot.writeI64(self.itemId)
27869 
      oprot.writeFieldEnd()
10909 vikram.rag 27870 
    oprot.writeFieldStop()
27871 
    oprot.writeStructEnd()
27872 
 
27873 
  def validate(self):
27874 
    return
27875 
 
27876 
 
27877 
  def __repr__(self):
27878 
    L = ['%s=%r' % (key, value)
27879 
      for key, value in self.__dict__.iteritems()]
27880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27881 
 
27882 
  def __eq__(self, other):
27883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27884 
 
27885 
  def __ne__(self, other):
27886 
    return not (self == other)
27887 
 
11015 kshitij.so 27888 
class getMarketplaceHistory_result:
10909 vikram.rag 27889 
  """
27890 
  Attributes:
27891 
   - success
27892 
  """
27893 
 
27894 
  thrift_spec = (
11015 kshitij.so 27895 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
10909 vikram.rag 27896 
  )
27897 
 
27898 
  def __init__(self, success=None,):
27899 
    self.success = success
27900 
 
27901 
  def read(self, iprot):
27902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27904 
      return
27905 
    iprot.readStructBegin()
27906 
    while True:
27907 
      (fname, ftype, fid) = iprot.readFieldBegin()
27908 
      if ftype == TType.STOP:
27909 
        break
27910 
      if fid == 0:
27911 
        if ftype == TType.LIST:
27912 
          self.success = []
27913 
          (_etype623, _size620) = iprot.readListBegin()
27914 
          for _i624 in xrange(_size620):
11015 kshitij.so 27915 
            _elem625 = MarketplaceHistory()
10909 vikram.rag 27916 
            _elem625.read(iprot)
27917 
            self.success.append(_elem625)
27918 
          iprot.readListEnd()
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
11015 kshitij.so 27930 
    oprot.writeStructBegin('getMarketplaceHistory_result')
10909 vikram.rag 27931 
    if self.success is not None:
27932 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27933 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27934 
      for iter626 in self.success:
27935 
        iter626.write(oprot)
27936 
      oprot.writeListEnd()
27937 
      oprot.writeFieldEnd()
27938 
    oprot.writeFieldStop()
27939 
    oprot.writeStructEnd()
27940 
 
27941 
  def validate(self):
27942 
    return
27943 
 
27944 
 
27945 
  def __repr__(self):
27946 
    L = ['%s=%r' % (key, value)
27947 
      for key, value in self.__dict__.iteritems()]
27948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27949 
 
27950 
  def __eq__(self, other):
27951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27952 
 
27953 
  def __ne__(self, other):
27954 
    return not (self == other)
10924 vikram.rag 27955 
 
11015 kshitij.so 27956 
class getAllFbbListedItems_args:
10924 vikram.rag 27957 
 
27958 
  thrift_spec = (
27959 
  )
27960 
 
27961 
  def read(self, iprot):
27962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27964 
      return
27965 
    iprot.readStructBegin()
27966 
    while True:
27967 
      (fname, ftype, fid) = iprot.readFieldBegin()
27968 
      if ftype == TType.STOP:
27969 
        break
27970 
      else:
27971 
        iprot.skip(ftype)
27972 
      iprot.readFieldEnd()
27973 
    iprot.readStructEnd()
27974 
 
27975 
  def write(self, oprot):
27976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27978 
      return
11015 kshitij.so 27979 
    oprot.writeStructBegin('getAllFbbListedItems_args')
10924 vikram.rag 27980 
    oprot.writeFieldStop()
27981 
    oprot.writeStructEnd()
27982 
 
27983 
  def validate(self):
27984 
    return
27985 
 
27986 
 
27987 
  def __repr__(self):
27988 
    L = ['%s=%r' % (key, value)
27989 
      for key, value in self.__dict__.iteritems()]
27990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27991 
 
27992 
  def __eq__(self, other):
27993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27994 
 
27995 
  def __ne__(self, other):
27996 
    return not (self == other)
27997 
 
11015 kshitij.so 27998 
class getAllFbbListedItems_result:
10924 vikram.rag 27999 
  """
28000 
  Attributes:
28001 
   - success
28002 
  """
28003 
 
28004 
  thrift_spec = (
28005 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
28006 
  )
28007 
 
28008 
  def __init__(self, success=None,):
28009 
    self.success = success
28010 
 
28011 
  def read(self, iprot):
28012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28014 
      return
28015 
    iprot.readStructBegin()
28016 
    while True:
28017 
      (fname, ftype, fid) = iprot.readFieldBegin()
28018 
      if ftype == TType.STOP:
28019 
        break
28020 
      if fid == 0:
28021 
        if ftype == TType.LIST:
28022 
          self.success = []
28023 
          (_etype630, _size627) = iprot.readListBegin()
28024 
          for _i631 in xrange(_size627):
28025 
            _elem632 = Amazonlisted()
28026 
            _elem632.read(iprot)
28027 
            self.success.append(_elem632)
28028 
          iprot.readListEnd()
28029 
        else:
28030 
          iprot.skip(ftype)
28031 
      else:
28032 
        iprot.skip(ftype)
28033 
      iprot.readFieldEnd()
28034 
    iprot.readStructEnd()
28035 
 
28036 
  def write(self, oprot):
28037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28039 
      return
11015 kshitij.so 28040 
    oprot.writeStructBegin('getAllFbbListedItems_result')
10924 vikram.rag 28041 
    if self.success is not None:
28042 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28043 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28044 
      for iter633 in self.success:
28045 
        iter633.write(oprot)
28046 
      oprot.writeListEnd()
28047 
      oprot.writeFieldEnd()
28048 
    oprot.writeFieldStop()
28049 
    oprot.writeStructEnd()
28050 
 
28051 
  def validate(self):
28052 
    return
28053 
 
28054 
 
28055 
  def __repr__(self):
28056 
    L = ['%s=%r' % (key, value)
28057 
      for key, value in self.__dict__.iteritems()]
28058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28059 
 
28060 
  def __eq__(self, other):
28061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28062 
 
28063 
  def __ne__(self, other):
28064 
    return not (self == other)
11015 kshitij.so 28065 
 
28066 
class getAllFbbPricingItems_args:
28067 
 
28068 
  thrift_spec = (
28069 
  )
28070 
 
28071 
  def read(self, iprot):
28072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28074 
      return
28075 
    iprot.readStructBegin()
28076 
    while True:
28077 
      (fname, ftype, fid) = iprot.readFieldBegin()
28078 
      if ftype == TType.STOP:
28079 
        break
28080 
      else:
28081 
        iprot.skip(ftype)
28082 
      iprot.readFieldEnd()
28083 
    iprot.readStructEnd()
28084 
 
28085 
  def write(self, oprot):
28086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28088 
      return
28089 
    oprot.writeStructBegin('getAllFbbPricingItems_args')
28090 
    oprot.writeFieldStop()
28091 
    oprot.writeStructEnd()
28092 
 
28093 
  def validate(self):
28094 
    return
28095 
 
28096 
 
28097 
  def __repr__(self):
28098 
    L = ['%s=%r' % (key, value)
28099 
      for key, value in self.__dict__.iteritems()]
28100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28101 
 
28102 
  def __eq__(self, other):
28103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28104 
 
28105 
  def __ne__(self, other):
28106 
    return not (self == other)
28107 
 
28108 
class getAllFbbPricingItems_result:
28109 
  """
28110 
  Attributes:
28111 
   - success
28112 
  """
28113 
 
28114 
  thrift_spec = (
28115 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
28116 
  )
28117 
 
28118 
  def __init__(self, success=None,):
28119 
    self.success = success
28120 
 
28121 
  def read(self, iprot):
28122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28124 
      return
28125 
    iprot.readStructBegin()
28126 
    while True:
28127 
      (fname, ftype, fid) = iprot.readFieldBegin()
28128 
      if ftype == TType.STOP:
28129 
        break
28130 
      if fid == 0:
28131 
        if ftype == TType.LIST:
28132 
          self.success = []
28133 
          (_etype637, _size634) = iprot.readListBegin()
28134 
          for _i638 in xrange(_size634):
28135 
            _elem639 = Amazonlisted()
28136 
            _elem639.read(iprot)
28137 
            self.success.append(_elem639)
28138 
          iprot.readListEnd()
28139 
        else:
28140 
          iprot.skip(ftype)
28141 
      else:
28142 
        iprot.skip(ftype)
28143 
      iprot.readFieldEnd()
28144 
    iprot.readStructEnd()
28145 
 
28146 
  def write(self, oprot):
28147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28149 
      return
28150 
    oprot.writeStructBegin('getAllFbbPricingItems_result')
28151 
    if self.success is not None:
28152 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28153 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28154 
      for iter640 in self.success:
28155 
        iter640.write(oprot)
28156 
      oprot.writeListEnd()
28157 
      oprot.writeFieldEnd()
28158 
    oprot.writeFieldStop()
28159 
    oprot.writeStructEnd()
28160 
 
28161 
  def validate(self):
28162 
    return
28163 
 
28164 
 
28165 
  def __repr__(self):
28166 
    L = ['%s=%r' % (key, value)
28167 
      for key, value in self.__dict__.iteritems()]
28168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28169 
 
28170 
  def __eq__(self, other):
28171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28172 
 
28173 
  def __ne__(self, other):
28174 
    return not (self == other)
28175 
 
28176 
class getCountForMarketplaceHistory_args:
28177 
  """
28178 
  Attributes:
28179 
   - source
28180 
   - itemId
28181 
  """
28182 
 
28183 
  thrift_spec = (
28184 
    None, # 0
28185 
    (1, TType.I64, 'source', None, None, ), # 1
28186 
    (2, TType.I64, 'itemId', None, None, ), # 2
28187 
  )
28188 
 
28189 
  def __init__(self, source=None, itemId=None,):
28190 
    self.source = source
28191 
    self.itemId = itemId
28192 
 
28193 
  def read(self, iprot):
28194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28196 
      return
28197 
    iprot.readStructBegin()
28198 
    while True:
28199 
      (fname, ftype, fid) = iprot.readFieldBegin()
28200 
      if ftype == TType.STOP:
28201 
        break
28202 
      if fid == 1:
28203 
        if ftype == TType.I64:
28204 
          self.source = iprot.readI64();
28205 
        else:
28206 
          iprot.skip(ftype)
28207 
      elif fid == 2:
28208 
        if ftype == TType.I64:
28209 
          self.itemId = iprot.readI64();
28210 
        else:
28211 
          iprot.skip(ftype)
28212 
      else:
28213 
        iprot.skip(ftype)
28214 
      iprot.readFieldEnd()
28215 
    iprot.readStructEnd()
28216 
 
28217 
  def write(self, oprot):
28218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28220 
      return
28221 
    oprot.writeStructBegin('getCountForMarketplaceHistory_args')
28222 
    if self.source is not None:
28223 
      oprot.writeFieldBegin('source', TType.I64, 1)
28224 
      oprot.writeI64(self.source)
28225 
      oprot.writeFieldEnd()
28226 
    if self.itemId is not None:
28227 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
28228 
      oprot.writeI64(self.itemId)
28229 
      oprot.writeFieldEnd()
28230 
    oprot.writeFieldStop()
28231 
    oprot.writeStructEnd()
28232 
 
28233 
  def validate(self):
28234 
    return
28235 
 
28236 
 
28237 
  def __repr__(self):
28238 
    L = ['%s=%r' % (key, value)
28239 
      for key, value in self.__dict__.iteritems()]
28240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28241 
 
28242 
  def __eq__(self, other):
28243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28244 
 
28245 
  def __ne__(self, other):
28246 
    return not (self == other)
28247 
 
28248 
class getCountForMarketplaceHistory_result:
28249 
  """
28250 
  Attributes:
28251 
   - success
28252 
  """
28253 
 
28254 
  thrift_spec = (
28255 
    (0, TType.I64, 'success', None, None, ), # 0
28256 
  )
28257 
 
28258 
  def __init__(self, success=None,):
28259 
    self.success = success
28260 
 
28261 
  def read(self, iprot):
28262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28264 
      return
28265 
    iprot.readStructBegin()
28266 
    while True:
28267 
      (fname, ftype, fid) = iprot.readFieldBegin()
28268 
      if ftype == TType.STOP:
28269 
        break
28270 
      if fid == 0:
28271 
        if ftype == TType.I64:
28272 
          self.success = iprot.readI64();
28273 
        else:
28274 
          iprot.skip(ftype)
28275 
      else:
28276 
        iprot.skip(ftype)
28277 
      iprot.readFieldEnd()
28278 
    iprot.readStructEnd()
28279 
 
28280 
  def write(self, oprot):
28281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28283 
      return
28284 
    oprot.writeStructBegin('getCountForMarketplaceHistory_result')
28285 
    if self.success is not None:
28286 
      oprot.writeFieldBegin('success', TType.I64, 0)
28287 
      oprot.writeI64(self.success)
28288 
      oprot.writeFieldEnd()
28289 
    oprot.writeFieldStop()
28290 
    oprot.writeStructEnd()
28291 
 
28292 
  def validate(self):
28293 
    return
28294 
 
28295 
 
28296 
  def __repr__(self):
28297 
    L = ['%s=%r' % (key, value)
28298 
      for key, value in self.__dict__.iteritems()]
28299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28300 
 
28301 
  def __eq__(self, other):
28302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28303 
 
28304 
  def __ne__(self, other):
28305 
    return not (self == other)
28306 
 
28307 
class getMarketplaceHistoryByDate_args:
28308 
  """
28309 
  Attributes:
28310 
   - source
28311 
   - startDate
28312 
   - endDate
28313 
   - offset
28314 
   - limit
28315 
   - itemId
28316 
  """
28317 
 
28318 
  thrift_spec = (
28319 
    None, # 0
28320 
    (1, TType.I64, 'source', None, None, ), # 1
28321 
    (2, TType.I64, 'startDate', None, None, ), # 2
28322 
    (3, TType.I64, 'endDate', None, None, ), # 3
28323 
    (4, TType.I64, 'offset', None, None, ), # 4
28324 
    (5, TType.I64, 'limit', None, None, ), # 5
28325 
    (6, TType.I64, 'itemId', None, None, ), # 6
28326 
  )
28327 
 
28328 
  def __init__(self, source=None, startDate=None, endDate=None, offset=None, limit=None, itemId=None,):
28329 
    self.source = source
28330 
    self.startDate = startDate
28331 
    self.endDate = endDate
28332 
    self.offset = offset
28333 
    self.limit = limit
28334 
    self.itemId = itemId
28335 
 
28336 
  def read(self, iprot):
28337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28339 
      return
28340 
    iprot.readStructBegin()
28341 
    while True:
28342 
      (fname, ftype, fid) = iprot.readFieldBegin()
28343 
      if ftype == TType.STOP:
28344 
        break
28345 
      if fid == 1:
28346 
        if ftype == TType.I64:
28347 
          self.source = iprot.readI64();
28348 
        else:
28349 
          iprot.skip(ftype)
28350 
      elif fid == 2:
28351 
        if ftype == TType.I64:
28352 
          self.startDate = iprot.readI64();
28353 
        else:
28354 
          iprot.skip(ftype)
28355 
      elif fid == 3:
28356 
        if ftype == TType.I64:
28357 
          self.endDate = iprot.readI64();
28358 
        else:
28359 
          iprot.skip(ftype)
28360 
      elif fid == 4:
28361 
        if ftype == TType.I64:
28362 
          self.offset = iprot.readI64();
28363 
        else:
28364 
          iprot.skip(ftype)
28365 
      elif fid == 5:
28366 
        if ftype == TType.I64:
28367 
          self.limit = iprot.readI64();
28368 
        else:
28369 
          iprot.skip(ftype)
28370 
      elif fid == 6:
28371 
        if ftype == TType.I64:
28372 
          self.itemId = iprot.readI64();
28373 
        else:
28374 
          iprot.skip(ftype)
28375 
      else:
28376 
        iprot.skip(ftype)
28377 
      iprot.readFieldEnd()
28378 
    iprot.readStructEnd()
28379 
 
28380 
  def write(self, oprot):
28381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28383 
      return
28384 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_args')
28385 
    if self.source is not None:
28386 
      oprot.writeFieldBegin('source', TType.I64, 1)
28387 
      oprot.writeI64(self.source)
28388 
      oprot.writeFieldEnd()
28389 
    if self.startDate is not None:
28390 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
28391 
      oprot.writeI64(self.startDate)
28392 
      oprot.writeFieldEnd()
28393 
    if self.endDate is not None:
28394 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
28395 
      oprot.writeI64(self.endDate)
28396 
      oprot.writeFieldEnd()
28397 
    if self.offset is not None:
28398 
      oprot.writeFieldBegin('offset', TType.I64, 4)
28399 
      oprot.writeI64(self.offset)
28400 
      oprot.writeFieldEnd()
28401 
    if self.limit is not None:
28402 
      oprot.writeFieldBegin('limit', TType.I64, 5)
28403 
      oprot.writeI64(self.limit)
28404 
      oprot.writeFieldEnd()
28405 
    if self.itemId is not None:
28406 
      oprot.writeFieldBegin('itemId', TType.I64, 6)
28407 
      oprot.writeI64(self.itemId)
28408 
      oprot.writeFieldEnd()
28409 
    oprot.writeFieldStop()
28410 
    oprot.writeStructEnd()
28411 
 
28412 
  def validate(self):
28413 
    return
28414 
 
28415 
 
28416 
  def __repr__(self):
28417 
    L = ['%s=%r' % (key, value)
28418 
      for key, value in self.__dict__.iteritems()]
28419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28420 
 
28421 
  def __eq__(self, other):
28422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28423 
 
28424 
  def __ne__(self, other):
28425 
    return not (self == other)
28426 
 
28427 
class getMarketplaceHistoryByDate_result:
28428 
  """
28429 
  Attributes:
28430 
   - success
28431 
  """
28432 
 
28433 
  thrift_spec = (
28434 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
28435 
  )
28436 
 
28437 
  def __init__(self, success=None,):
28438 
    self.success = success
28439 
 
28440 
  def read(self, iprot):
28441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28443 
      return
28444 
    iprot.readStructBegin()
28445 
    while True:
28446 
      (fname, ftype, fid) = iprot.readFieldBegin()
28447 
      if ftype == TType.STOP:
28448 
        break
28449 
      if fid == 0:
28450 
        if ftype == TType.LIST:
28451 
          self.success = []
28452 
          (_etype644, _size641) = iprot.readListBegin()
28453 
          for _i645 in xrange(_size641):
28454 
            _elem646 = MarketplaceHistory()
28455 
            _elem646.read(iprot)
28456 
            self.success.append(_elem646)
28457 
          iprot.readListEnd()
28458 
        else:
28459 
          iprot.skip(ftype)
28460 
      else:
28461 
        iprot.skip(ftype)
28462 
      iprot.readFieldEnd()
28463 
    iprot.readStructEnd()
28464 
 
28465 
  def write(self, oprot):
28466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28468 
      return
28469 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_result')
28470 
    if self.success is not None:
28471 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28472 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28473 
      for iter647 in self.success:
28474 
        iter647.write(oprot)
28475 
      oprot.writeListEnd()
28476 
      oprot.writeFieldEnd()
28477 
    oprot.writeFieldStop()
28478 
    oprot.writeStructEnd()
28479 
 
28480 
  def validate(self):
28481 
    return
28482 
 
28483 
 
28484 
  def __repr__(self):
28485 
    L = ['%s=%r' % (key, value)
28486 
      for key, value in self.__dict__.iteritems()]
28487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28488 
 
28489 
  def __eq__(self, other):
28490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28491 
 
28492 
  def __ne__(self, other):
28493 
    return not (self == other)
11531 vikram.rag 28494 
 
28495 
class getPrivateDealDetails_args:
28496 
  """
28497 
  Attributes:
28498 
   - item_id
28499 
  """
28500 
 
28501 
  thrift_spec = (
28502 
    None, # 0
28503 
    (1, TType.I64, 'item_id', None, None, ), # 1
28504 
  )
28505 
 
28506 
  def __init__(self, item_id=None,):
28507 
    self.item_id = item_id
28508 
 
28509 
  def read(self, iprot):
28510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28512 
      return
28513 
    iprot.readStructBegin()
28514 
    while True:
28515 
      (fname, ftype, fid) = iprot.readFieldBegin()
28516 
      if ftype == TType.STOP:
28517 
        break
28518 
      if fid == 1:
28519 
        if ftype == TType.I64:
28520 
          self.item_id = iprot.readI64();
28521 
        else:
28522 
          iprot.skip(ftype)
28523 
      else:
28524 
        iprot.skip(ftype)
28525 
      iprot.readFieldEnd()
28526 
    iprot.readStructEnd()
28527 
 
28528 
  def write(self, oprot):
28529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28531 
      return
28532 
    oprot.writeStructBegin('getPrivateDealDetails_args')
28533 
    if self.item_id is not None:
28534 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
28535 
      oprot.writeI64(self.item_id)
28536 
      oprot.writeFieldEnd()
28537 
    oprot.writeFieldStop()
28538 
    oprot.writeStructEnd()
28539 
 
28540 
  def validate(self):
28541 
    return
28542 
 
28543 
 
28544 
  def __repr__(self):
28545 
    L = ['%s=%r' % (key, value)
28546 
      for key, value in self.__dict__.iteritems()]
28547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28548 
 
28549 
  def __eq__(self, other):
28550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28551 
 
28552 
  def __ne__(self, other):
28553 
    return not (self == other)
28554 
 
28555 
class getPrivateDealDetails_result:
28556 
  """
28557 
  Attributes:
28558 
   - success
28559 
  """
28560 
 
28561 
  thrift_spec = (
28562 
    (0, TType.STRUCT, 'success', (PrivateDeal, PrivateDeal.thrift_spec), None, ), # 0
28563 
  )
28564 
 
28565 
  def __init__(self, success=None,):
28566 
    self.success = success
28567 
 
28568 
  def read(self, iprot):
28569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28571 
      return
28572 
    iprot.readStructBegin()
28573 
    while True:
28574 
      (fname, ftype, fid) = iprot.readFieldBegin()
28575 
      if ftype == TType.STOP:
28576 
        break
28577 
      if fid == 0:
28578 
        if ftype == TType.STRUCT:
28579 
          self.success = PrivateDeal()
28580 
          self.success.read(iprot)
28581 
        else:
28582 
          iprot.skip(ftype)
28583 
      else:
28584 
        iprot.skip(ftype)
28585 
      iprot.readFieldEnd()
28586 
    iprot.readStructEnd()
28587 
 
28588 
  def write(self, oprot):
28589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28591 
      return
28592 
    oprot.writeStructBegin('getPrivateDealDetails_result')
28593 
    if self.success is not None:
28594 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28595 
      self.success.write(oprot)
28596 
      oprot.writeFieldEnd()
28597 
    oprot.writeFieldStop()
28598 
    oprot.writeStructEnd()
28599 
 
28600 
  def validate(self):
28601 
    return
28602 
 
28603 
 
28604 
  def __repr__(self):
28605 
    L = ['%s=%r' % (key, value)
28606 
      for key, value in self.__dict__.iteritems()]
28607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28608 
 
28609 
  def __eq__(self, other):
28610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28611 
 
28612 
  def __ne__(self, other):
28613 
    return not (self == other)
28614 
 
28615 
class getPrivateDealItems_args:
28616 
  """
28617 
  Attributes:
28618 
   - offset
28619 
   - limit
28620 
  """
28621 
 
28622 
  thrift_spec = (
28623 
    None, # 0
28624 
    (1, TType.I64, 'offset', None, None, ), # 1
28625 
    (2, TType.I64, 'limit', None, None, ), # 2
28626 
  )
28627 
 
28628 
  def __init__(self, offset=None, limit=None,):
28629 
    self.offset = offset
28630 
    self.limit = limit
28631 
 
28632 
  def read(self, iprot):
28633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28635 
      return
28636 
    iprot.readStructBegin()
28637 
    while True:
28638 
      (fname, ftype, fid) = iprot.readFieldBegin()
28639 
      if ftype == TType.STOP:
28640 
        break
28641 
      if fid == 1:
28642 
        if ftype == TType.I64:
28643 
          self.offset = iprot.readI64();
28644 
        else:
28645 
          iprot.skip(ftype)
28646 
      elif fid == 2:
28647 
        if ftype == TType.I64:
28648 
          self.limit = iprot.readI64();
28649 
        else:
28650 
          iprot.skip(ftype)
28651 
      else:
28652 
        iprot.skip(ftype)
28653 
      iprot.readFieldEnd()
28654 
    iprot.readStructEnd()
28655 
 
28656 
  def write(self, oprot):
28657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28659 
      return
28660 
    oprot.writeStructBegin('getPrivateDealItems_args')
28661 
    if self.offset is not None:
28662 
      oprot.writeFieldBegin('offset', TType.I64, 1)
28663 
      oprot.writeI64(self.offset)
28664 
      oprot.writeFieldEnd()
28665 
    if self.limit is not None:
28666 
      oprot.writeFieldBegin('limit', TType.I64, 2)
28667 
      oprot.writeI64(self.limit)
28668 
      oprot.writeFieldEnd()
28669 
    oprot.writeFieldStop()
28670 
    oprot.writeStructEnd()
28671 
 
28672 
  def validate(self):
28673 
    return
28674 
 
28675 
 
28676 
  def __repr__(self):
28677 
    L = ['%s=%r' % (key, value)
28678 
      for key, value in self.__dict__.iteritems()]
28679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28680 
 
28681 
  def __eq__(self, other):
28682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28683 
 
28684 
  def __ne__(self, other):
28685 
    return not (self == other)
28686 
 
28687 
class getPrivateDealItems_result:
28688 
  """
28689 
  Attributes:
28690 
   - success
28691 
  """
28692 
 
28693 
  thrift_spec = (
28694 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
28695 
  )
28696 
 
28697 
  def __init__(self, success=None,):
28698 
    self.success = success
28699 
 
28700 
  def read(self, iprot):
28701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28703 
      return
28704 
    iprot.readStructBegin()
28705 
    while True:
28706 
      (fname, ftype, fid) = iprot.readFieldBegin()
28707 
      if ftype == TType.STOP:
28708 
        break
28709 
      if fid == 0:
28710 
        if ftype == TType.LIST:
28711 
          self.success = []
28712 
          (_etype651, _size648) = iprot.readListBegin()
28713 
          for _i652 in xrange(_size648):
28714 
            _elem653 = Item()
28715 
            _elem653.read(iprot)
28716 
            self.success.append(_elem653)
28717 
          iprot.readListEnd()
28718 
        else:
28719 
          iprot.skip(ftype)
28720 
      else:
28721 
        iprot.skip(ftype)
28722 
      iprot.readFieldEnd()
28723 
    iprot.readStructEnd()
28724 
 
28725 
  def write(self, oprot):
28726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28728 
      return
28729 
    oprot.writeStructBegin('getPrivateDealItems_result')
28730 
    if self.success is not None:
28731 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28732 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28733 
      for iter654 in self.success:
28734 
        iter654.write(oprot)
28735 
      oprot.writeListEnd()
28736 
      oprot.writeFieldEnd()
28737 
    oprot.writeFieldStop()
28738 
    oprot.writeStructEnd()
28739 
 
28740 
  def validate(self):
28741 
    return
28742 
 
28743 
 
28744 
  def __repr__(self):
28745 
    L = ['%s=%r' % (key, value)
28746 
      for key, value in self.__dict__.iteritems()]
28747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28748 
 
28749 
  def __eq__(self, other):
28750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28751 
 
28752 
  def __ne__(self, other):
28753 
    return not (self == other)
28754 
 
28755 
class addOrUpdatePrivateDeal_args:
28756 
  """
28757 
  Attributes:
28758 
   - privateDeal
28759 
  """
28760 
 
28761 
  thrift_spec = (
28762 
    None, # 0
28763 
    (1, TType.STRUCT, 'privateDeal', (PrivateDeal, PrivateDeal.thrift_spec), None, ), # 1
28764 
  )
28765 
 
28766 
  def __init__(self, privateDeal=None,):
28767 
    self.privateDeal = privateDeal
28768 
 
28769 
  def read(self, iprot):
28770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28772 
      return
28773 
    iprot.readStructBegin()
28774 
    while True:
28775 
      (fname, ftype, fid) = iprot.readFieldBegin()
28776 
      if ftype == TType.STOP:
28777 
        break
28778 
      if fid == 1:
28779 
        if ftype == TType.STRUCT:
28780 
          self.privateDeal = PrivateDeal()
28781 
          self.privateDeal.read(iprot)
28782 
        else:
28783 
          iprot.skip(ftype)
28784 
      else:
28785 
        iprot.skip(ftype)
28786 
      iprot.readFieldEnd()
28787 
    iprot.readStructEnd()
28788 
 
28789 
  def write(self, oprot):
28790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28792 
      return
28793 
    oprot.writeStructBegin('addOrUpdatePrivateDeal_args')
28794 
    if self.privateDeal is not None:
28795 
      oprot.writeFieldBegin('privateDeal', TType.STRUCT, 1)
28796 
      self.privateDeal.write(oprot)
28797 
      oprot.writeFieldEnd()
28798 
    oprot.writeFieldStop()
28799 
    oprot.writeStructEnd()
28800 
 
28801 
  def validate(self):
28802 
    return
28803 
 
28804 
 
28805 
  def __repr__(self):
28806 
    L = ['%s=%r' % (key, value)
28807 
      for key, value in self.__dict__.iteritems()]
28808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28809 
 
28810 
  def __eq__(self, other):
28811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28812 
 
28813 
  def __ne__(self, other):
28814 
    return not (self == other)
28815 
 
28816 
class addOrUpdatePrivateDeal_result:
28817 
  """
28818 
  Attributes:
28819 
   - success
28820 
  """
28821 
 
28822 
  thrift_spec = (
28823 
    (0, TType.BOOL, 'success', None, None, ), # 0
28824 
  )
28825 
 
28826 
  def __init__(self, success=None,):
28827 
    self.success = success
28828 
 
28829 
  def read(self, iprot):
28830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28832 
      return
28833 
    iprot.readStructBegin()
28834 
    while True:
28835 
      (fname, ftype, fid) = iprot.readFieldBegin()
28836 
      if ftype == TType.STOP:
28837 
        break
28838 
      if fid == 0:
28839 
        if ftype == TType.BOOL:
28840 
          self.success = iprot.readBool();
28841 
        else:
28842 
          iprot.skip(ftype)
28843 
      else:
28844 
        iprot.skip(ftype)
28845 
      iprot.readFieldEnd()
28846 
    iprot.readStructEnd()
28847 
 
28848 
  def write(self, oprot):
28849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28851 
      return
28852 
    oprot.writeStructBegin('addOrUpdatePrivateDeal_result')
28853 
    if self.success is not None:
28854 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28855 
      oprot.writeBool(self.success)
28856 
      oprot.writeFieldEnd()
28857 
    oprot.writeFieldStop()
28858 
    oprot.writeStructEnd()
28859 
 
28860 
  def validate(self):
28861 
    return
28862 
 
28863 
 
28864 
  def __repr__(self):
28865 
    L = ['%s=%r' % (key, value)
28866 
      for key, value in self.__dict__.iteritems()]
28867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28868 
 
28869 
  def __eq__(self, other):
28870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28871 
 
28872 
  def __ne__(self, other):
28873 
    return not (self == other)