Subversion Repositories SmartDukaan

Rev

Rev 11531 | Rev 11635 | 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 
 
11592 amit.gupta 1164 
  def getAllActivePrivateDeals(self, ):
1165 
    pass
1166 
 
11531 vikram.rag 1167 
  def addOrUpdatePrivateDeal(self, privateDeal):
1168 
    """
1169 
    Parameters:
1170 
     - privateDeal
1171 
    """
1172 
    pass
1173 
 
1174 
 
5944 mandeep.dh 1175 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1176 
  def __init__(self, iprot, oprot=None):
1177 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1178 
 
1179 
  def addItem(self, item):
1180 
    """
1181 
    Availability and inventory attributes
1182 
 
1183 
    Parameters:
1184 
     - item
1185 
    """
1186 
    self.send_addItem(item)
1187 
    return self.recv_addItem()
1188 
 
1189 
  def send_addItem(self, item):
1190 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1191 
    args = addItem_args()
1192 
    args.item = item
1193 
    args.write(self._oprot)
1194 
    self._oprot.writeMessageEnd()
1195 
    self._oprot.trans.flush()
1196 
 
1197 
  def recv_addItem(self, ):
1198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1199 
    if mtype == TMessageType.EXCEPTION:
1200 
      x = TApplicationException()
1201 
      x.read(self._iprot)
1202 
      self._iprot.readMessageEnd()
1203 
      raise x
1204 
    result = addItem_result()
1205 
    result.read(self._iprot)
1206 
    self._iprot.readMessageEnd()
1207 
    if result.success is not None:
1208 
      return result.success
1209 
    if result.cex is not None:
1210 
      raise result.cex
1211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1212 
 
1213 
  def updateItem(self, item):
1214 
    """
1215 
    Parameters:
1216 
     - item
1217 
    """
1218 
    self.send_updateItem(item)
1219 
    return self.recv_updateItem()
1220 
 
1221 
  def send_updateItem(self, item):
1222 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1223 
    args = updateItem_args()
1224 
    args.item = item
1225 
    args.write(self._oprot)
1226 
    self._oprot.writeMessageEnd()
1227 
    self._oprot.trans.flush()
1228 
 
1229 
  def recv_updateItem(self, ):
1230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1231 
    if mtype == TMessageType.EXCEPTION:
1232 
      x = TApplicationException()
1233 
      x.read(self._iprot)
1234 
      self._iprot.readMessageEnd()
1235 
      raise x
1236 
    result = updateItem_result()
1237 
    result.read(self._iprot)
1238 
    self._iprot.readMessageEnd()
1239 
    if result.success is not None:
1240 
      return result.success
1241 
    if result.cex is not None:
1242 
      raise result.cex
1243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1244 
 
1245 
  def isActive(self, itemId):
1246 
    """
1247 
    Checks if the item given to the corresponding itemId is active. If it's active,
1248 
    whether it's risky and if it's risky, its inventory position.
1249 
 
1250 
    Parameters:
1251 
     - itemId
1252 
    """
1253 
    self.send_isActive(itemId)
1254 
    return self.recv_isActive()
1255 
 
1256 
  def send_isActive(self, itemId):
1257 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1258 
    args = isActive_args()
1259 
    args.itemId = itemId
1260 
    args.write(self._oprot)
1261 
    self._oprot.writeMessageEnd()
1262 
    self._oprot.trans.flush()
1263 
 
1264 
  def recv_isActive(self, ):
1265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1266 
    if mtype == TMessageType.EXCEPTION:
1267 
      x = TApplicationException()
1268 
      x.read(self._iprot)
1269 
      self._iprot.readMessageEnd()
1270 
      raise x
1271 
    result = isActive_result()
1272 
    result.read(self._iprot)
1273 
    self._iprot.readMessageEnd()
1274 
    if result.success is not None:
1275 
      return result.success
1276 
    if result.isex is not None:
1277 
      raise result.isex
1278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1279 
 
7438 amit.gupta 1280 
  def getItemsStatus(self, itemIds):
1281 
    """
1282 
    Parameters:
1283 
     - itemIds
1284 
    """
1285 
    self.send_getItemsStatus(itemIds)
1286 
    return self.recv_getItemsStatus()
1287 
 
1288 
  def send_getItemsStatus(self, itemIds):
1289 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1290 
    args = getItemsStatus_args()
1291 
    args.itemIds = itemIds
1292 
    args.write(self._oprot)
1293 
    self._oprot.writeMessageEnd()
1294 
    self._oprot.trans.flush()
1295 
 
1296 
  def recv_getItemsStatus(self, ):
1297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1298 
    if mtype == TMessageType.EXCEPTION:
1299 
      x = TApplicationException()
1300 
      x.read(self._iprot)
1301 
      self._iprot.readMessageEnd()
1302 
      raise x
1303 
    result = getItemsStatus_result()
1304 
    result.read(self._iprot)
1305 
    self._iprot.readMessageEnd()
1306 
    if result.success is not None:
1307 
      return result.success
1308 
    if result.isex is not None:
1309 
      raise result.isex
1310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1311 
 
5944 mandeep.dh 1312 
  def getItemStatusDescription(self, itemId):
1313 
    """
1314 
    Parameters:
1315 
     - itemId
1316 
    """
1317 
    self.send_getItemStatusDescription(itemId)
1318 
    return self.recv_getItemStatusDescription()
1319 
 
1320 
  def send_getItemStatusDescription(self, itemId):
1321 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1322 
    args = getItemStatusDescription_args()
1323 
    args.itemId = itemId
1324 
    args.write(self._oprot)
1325 
    self._oprot.writeMessageEnd()
1326 
    self._oprot.trans.flush()
1327 
 
1328 
  def recv_getItemStatusDescription(self, ):
1329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1330 
    if mtype == TMessageType.EXCEPTION:
1331 
      x = TApplicationException()
1332 
      x.read(self._iprot)
1333 
      self._iprot.readMessageEnd()
1334 
      raise x
1335 
    result = getItemStatusDescription_result()
1336 
    result.read(self._iprot)
1337 
    self._iprot.readMessageEnd()
1338 
    if result.success is not None:
1339 
      return result.success
1340 
    if result.isex is not None:
1341 
      raise result.isex
1342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1343 
 
1344 
  def startItemOn(self, item_id, timestamp):
1345 
    """
1346 
    Parameters:
1347 
     - item_id
1348 
     - timestamp
1349 
    """
1350 
    self.send_startItemOn(item_id, timestamp)
1351 
    self.recv_startItemOn()
1352 
 
1353 
  def send_startItemOn(self, item_id, timestamp):
1354 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1355 
    args = startItemOn_args()
1356 
    args.item_id = item_id
1357 
    args.timestamp = timestamp
1358 
    args.write(self._oprot)
1359 
    self._oprot.writeMessageEnd()
1360 
    self._oprot.trans.flush()
1361 
 
1362 
  def recv_startItemOn(self, ):
1363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1364 
    if mtype == TMessageType.EXCEPTION:
1365 
      x = TApplicationException()
1366 
      x.read(self._iprot)
1367 
      self._iprot.readMessageEnd()
1368 
      raise x
1369 
    result = startItemOn_result()
1370 
    result.read(self._iprot)
1371 
    self._iprot.readMessageEnd()
1372 
    if result.cex is not None:
1373 
      raise result.cex
1374 
    return
1375 
 
1376 
  def retireItemOn(self, item_id, timestamp):
1377 
    """
1378 
    Parameters:
1379 
     - item_id
1380 
     - timestamp
1381 
    """
1382 
    self.send_retireItemOn(item_id, timestamp)
1383 
    self.recv_retireItemOn()
1384 
 
1385 
  def send_retireItemOn(self, item_id, timestamp):
1386 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1387 
    args = retireItemOn_args()
1388 
    args.item_id = item_id
1389 
    args.timestamp = timestamp
1390 
    args.write(self._oprot)
1391 
    self._oprot.writeMessageEnd()
1392 
    self._oprot.trans.flush()
1393 
 
1394 
  def recv_retireItemOn(self, ):
1395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1396 
    if mtype == TMessageType.EXCEPTION:
1397 
      x = TApplicationException()
1398 
      x.read(self._iprot)
1399 
      self._iprot.readMessageEnd()
1400 
      raise x
1401 
    result = retireItemOn_result()
1402 
    result.read(self._iprot)
1403 
    self._iprot.readMessageEnd()
1404 
    if result.cex is not None:
1405 
      raise result.cex
1406 
    return
1407 
 
1408 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1409 
    """
1410 
    Parameters:
1411 
     - item_id
1412 
     - timestamp
1413 
     - newstatus
1414 
    """
1415 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1416 
    self.recv_changeItemStatus()
1417 
 
1418 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1419 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1420 
    args = changeItemStatus_args()
1421 
    args.item_id = item_id
1422 
    args.timestamp = timestamp
1423 
    args.newstatus = newstatus
1424 
    args.write(self._oprot)
1425 
    self._oprot.writeMessageEnd()
1426 
    self._oprot.trans.flush()
1427 
 
1428 
  def recv_changeItemStatus(self, ):
1429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1430 
    if mtype == TMessageType.EXCEPTION:
1431 
      x = TApplicationException()
1432 
      x.read(self._iprot)
1433 
      self._iprot.readMessageEnd()
1434 
      raise x
1435 
    result = changeItemStatus_result()
1436 
    result.read(self._iprot)
1437 
    self._iprot.readMessageEnd()
1438 
    if result.cex is not None:
1439 
      raise result.cex
1440 
    return
1441 
 
1442 
  def getItem(self, item_id):
1443 
    """
1444 
    Parameters:
1445 
     - item_id
1446 
    """
1447 
    self.send_getItem(item_id)
1448 
    return self.recv_getItem()
1449 
 
1450 
  def send_getItem(self, item_id):
1451 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1452 
    args = getItem_args()
1453 
    args.item_id = item_id
1454 
    args.write(self._oprot)
1455 
    self._oprot.writeMessageEnd()
1456 
    self._oprot.trans.flush()
1457 
 
1458 
  def recv_getItem(self, ):
1459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1460 
    if mtype == TMessageType.EXCEPTION:
1461 
      x = TApplicationException()
1462 
      x.read(self._iprot)
1463 
      self._iprot.readMessageEnd()
1464 
      raise x
1465 
    result = getItem_result()
1466 
    result.read(self._iprot)
1467 
    self._iprot.readMessageEnd()
1468 
    if result.success is not None:
1469 
      return result.success
1470 
    if result.cex is not None:
1471 
      raise result.cex
1472 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1473 
 
1474 
  def getItemsByCatalogId(self, catalog_item_id):
1475 
    """
1476 
    Parameters:
1477 
     - catalog_item_id
1478 
    """
1479 
    self.send_getItemsByCatalogId(catalog_item_id)
1480 
    return self.recv_getItemsByCatalogId()
1481 
 
1482 
  def send_getItemsByCatalogId(self, catalog_item_id):
1483 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1484 
    args = getItemsByCatalogId_args()
1485 
    args.catalog_item_id = catalog_item_id
1486 
    args.write(self._oprot)
1487 
    self._oprot.writeMessageEnd()
1488 
    self._oprot.trans.flush()
1489 
 
1490 
  def recv_getItemsByCatalogId(self, ):
1491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1492 
    if mtype == TMessageType.EXCEPTION:
1493 
      x = TApplicationException()
1494 
      x.read(self._iprot)
1495 
      self._iprot.readMessageEnd()
1496 
      raise x
1497 
    result = getItemsByCatalogId_result()
1498 
    result.read(self._iprot)
1499 
    self._iprot.readMessageEnd()
1500 
    if result.success is not None:
1501 
      return result.success
1502 
    if result.cex is not None:
1503 
      raise result.cex
1504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1505 
 
1506 
  def getValidItemsByCatalogId(self, catalog_item_id):
1507 
    """
1508 
    Parameters:
1509 
     - catalog_item_id
1510 
    """
1511 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1512 
    return self.recv_getValidItemsByCatalogId()
1513 
 
1514 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1515 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1516 
    args = getValidItemsByCatalogId_args()
1517 
    args.catalog_item_id = catalog_item_id
1518 
    args.write(self._oprot)
1519 
    self._oprot.writeMessageEnd()
1520 
    self._oprot.trans.flush()
1521 
 
1522 
  def recv_getValidItemsByCatalogId(self, ):
1523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1524 
    if mtype == TMessageType.EXCEPTION:
1525 
      x = TApplicationException()
1526 
      x.read(self._iprot)
1527 
      self._iprot.readMessageEnd()
1528 
      raise x
1529 
    result = getValidItemsByCatalogId_result()
1530 
    result.read(self._iprot)
1531 
    self._iprot.readMessageEnd()
1532 
    if result.success is not None:
1533 
      return result.success
1534 
    if result.cex is not None:
1535 
      raise result.cex
1536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1537 
 
1538 
  def getAllItems(self, isActive):
1539 
    """
1540 
    Parameters:
1541 
     - isActive
1542 
    """
1543 
    self.send_getAllItems(isActive)
1544 
    return self.recv_getAllItems()
1545 
 
1546 
  def send_getAllItems(self, isActive):
1547 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1548 
    args = getAllItems_args()
1549 
    args.isActive = isActive
1550 
    args.write(self._oprot)
1551 
    self._oprot.writeMessageEnd()
1552 
    self._oprot.trans.flush()
1553 
 
1554 
  def recv_getAllItems(self, ):
1555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1556 
    if mtype == TMessageType.EXCEPTION:
1557 
      x = TApplicationException()
1558 
      x.read(self._iprot)
1559 
      self._iprot.readMessageEnd()
1560 
      raise x
1561 
    result = getAllItems_result()
1562 
    result.read(self._iprot)
1563 
    self._iprot.readMessageEnd()
1564 
    if result.success is not None:
1565 
      return result.success
1566 
    if result.cex is not None:
1567 
      raise result.cex
1568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1569 
 
1570 
  def getAllItemsByStatus(self, itemStatus):
1571 
    """
1572 
    Parameters:
1573 
     - itemStatus
1574 
    """
1575 
    self.send_getAllItemsByStatus(itemStatus)
1576 
    return self.recv_getAllItemsByStatus()
1577 
 
1578 
  def send_getAllItemsByStatus(self, itemStatus):
1579 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1580 
    args = getAllItemsByStatus_args()
1581 
    args.itemStatus = itemStatus
1582 
    args.write(self._oprot)
1583 
    self._oprot.writeMessageEnd()
1584 
    self._oprot.trans.flush()
1585 
 
1586 
  def recv_getAllItemsByStatus(self, ):
1587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1588 
    if mtype == TMessageType.EXCEPTION:
1589 
      x = TApplicationException()
1590 
      x.read(self._iprot)
1591 
      self._iprot.readMessageEnd()
1592 
      raise x
1593 
    result = getAllItemsByStatus_result()
1594 
    result.read(self._iprot)
1595 
    self._iprot.readMessageEnd()
1596 
    if result.success is not None:
1597 
      return result.success
1598 
    if result.cex is not None:
1599 
      raise result.cex
1600 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1601 
 
9253 rajveer 1602 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1603 
    """
1604 
    Parameters:
1605 
     - entityId
1606 
     - category
1607 
     - brand
1608 
     - modelName
1609 
     - modelNumber
9253 rajveer 1610 
     - isAndroid
5944 mandeep.dh 1611 
    """
9253 rajveer 1612 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1613 
    return self.recv_markItemAsContentComplete()
1614 
 
9253 rajveer 1615 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1616 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1617 
    args = markItemAsContentComplete_args()
1618 
    args.entityId = entityId
1619 
    args.category = category
1620 
    args.brand = brand
1621 
    args.modelName = modelName
1622 
    args.modelNumber = modelNumber
9253 rajveer 1623 
    args.isAndroid = isAndroid
5944 mandeep.dh 1624 
    args.write(self._oprot)
1625 
    self._oprot.writeMessageEnd()
1626 
    self._oprot.trans.flush()
1627 
 
1628 
  def recv_markItemAsContentComplete(self, ):
1629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1630 
    if mtype == TMessageType.EXCEPTION:
1631 
      x = TApplicationException()
1632 
      x.read(self._iprot)
1633 
      self._iprot.readMessageEnd()
1634 
      raise x
1635 
    result = markItemAsContentComplete_result()
1636 
    result.read(self._iprot)
1637 
    self._iprot.readMessageEnd()
1638 
    if result.success is not None:
1639 
      return result.success
1640 
    if result.cex is not None:
1641 
      raise result.cex
1642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1643 
 
1644 
  def getAllItemsInRange(self, offset, limit):
1645 
    """
1646 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1647 
 
1648 
    Parameters:
1649 
     - offset
1650 
     - limit
1651 
    """
1652 
    self.send_getAllItemsInRange(offset, limit)
1653 
    return self.recv_getAllItemsInRange()
1654 
 
1655 
  def send_getAllItemsInRange(self, offset, limit):
1656 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1657 
    args = getAllItemsInRange_args()
1658 
    args.offset = offset
1659 
    args.limit = limit
1660 
    args.write(self._oprot)
1661 
    self._oprot.writeMessageEnd()
1662 
    self._oprot.trans.flush()
1663 
 
1664 
  def recv_getAllItemsInRange(self, ):
1665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1666 
    if mtype == TMessageType.EXCEPTION:
1667 
      x = TApplicationException()
1668 
      x.read(self._iprot)
1669 
      self._iprot.readMessageEnd()
1670 
      raise x
1671 
    result = getAllItemsInRange_result()
1672 
    result.read(self._iprot)
1673 
    self._iprot.readMessageEnd()
1674 
    if result.success is not None:
1675 
      return result.success
1676 
    if result.cex is not None:
1677 
      raise result.cex
1678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1679 
 
1680 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1681 
    """
1682 
    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.
1683 
 
1684 
    Parameters:
1685 
     - itemStatus
1686 
     - offset
1687 
     - limit
1688 
    """
1689 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1690 
    return self.recv_getAllItemsByStatusInRange()
1691 
 
1692 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1693 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1694 
    args = getAllItemsByStatusInRange_args()
1695 
    args.itemStatus = itemStatus
1696 
    args.offset = offset
1697 
    args.limit = limit
1698 
    args.write(self._oprot)
1699 
    self._oprot.writeMessageEnd()
1700 
    self._oprot.trans.flush()
1701 
 
1702 
  def recv_getAllItemsByStatusInRange(self, ):
1703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1704 
    if mtype == TMessageType.EXCEPTION:
1705 
      x = TApplicationException()
1706 
      x.read(self._iprot)
1707 
      self._iprot.readMessageEnd()
1708 
      raise x
1709 
    result = getAllItemsByStatusInRange_result()
1710 
    result.read(self._iprot)
1711 
    self._iprot.readMessageEnd()
1712 
    if result.success is not None:
1713 
      return result.success
1714 
    if result.cex is not None:
1715 
      raise result.cex
1716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1717 
 
1718 
  def getItemCountByStatus(self, useStatus, itemStatus):
1719 
    """
1720 
    Gets a count of all items by status
1721 
 
1722 
    Parameters:
1723 
     - useStatus
1724 
     - itemStatus
1725 
    """
1726 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1727 
    return self.recv_getItemCountByStatus()
1728 
 
1729 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1730 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1731 
    args = getItemCountByStatus_args()
1732 
    args.useStatus = useStatus
1733 
    args.itemStatus = itemStatus
1734 
    args.write(self._oprot)
1735 
    self._oprot.writeMessageEnd()
1736 
    self._oprot.trans.flush()
1737 
 
1738 
  def recv_getItemCountByStatus(self, ):
1739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1740 
    if mtype == TMessageType.EXCEPTION:
1741 
      x = TApplicationException()
1742 
      x.read(self._iprot)
1743 
      self._iprot.readMessageEnd()
1744 
      raise x
1745 
    result = getItemCountByStatus_result()
1746 
    result.read(self._iprot)
1747 
    self._iprot.readMessageEnd()
1748 
    if result.success is not None:
1749 
      return result.success
1750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1751 
 
1752 
  def getBestSellers(self, ):
1753 
    self.send_getBestSellers()
1754 
    return self.recv_getBestSellers()
1755 
 
1756 
  def send_getBestSellers(self, ):
1757 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1758 
    args = getBestSellers_args()
1759 
    args.write(self._oprot)
1760 
    self._oprot.writeMessageEnd()
1761 
    self._oprot.trans.flush()
1762 
 
1763 
  def recv_getBestSellers(self, ):
1764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1765 
    if mtype == TMessageType.EXCEPTION:
1766 
      x = TApplicationException()
1767 
      x.read(self._iprot)
1768 
      self._iprot.readMessageEnd()
1769 
      raise x
1770 
    result = getBestSellers_result()
1771 
    result.read(self._iprot)
1772 
    self._iprot.readMessageEnd()
1773 
    if result.success is not None:
1774 
      return result.success
1775 
    if result.isex is not None:
1776 
      raise result.isex
1777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1778 
 
1779 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1780 
    """
1781 
    Parameters:
1782 
     - beginIndex
1783 
     - totalItems
1784 
     - brand
1785 
     - category
1786 
    """
1787 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1788 
    return self.recv_getBestSellersCatalogIds()
1789 
 
1790 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1791 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1792 
    args = getBestSellersCatalogIds_args()
1793 
    args.beginIndex = beginIndex
1794 
    args.totalItems = totalItems
1795 
    args.brand = brand
1796 
    args.category = category
1797 
    args.write(self._oprot)
1798 
    self._oprot.writeMessageEnd()
1799 
    self._oprot.trans.flush()
1800 
 
1801 
  def recv_getBestSellersCatalogIds(self, ):
1802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1803 
    if mtype == TMessageType.EXCEPTION:
1804 
      x = TApplicationException()
1805 
      x.read(self._iprot)
1806 
      self._iprot.readMessageEnd()
1807 
      raise x
1808 
    result = getBestSellersCatalogIds_result()
1809 
    result.read(self._iprot)
1810 
    self._iprot.readMessageEnd()
1811 
    if result.success is not None:
1812 
      return result.success
1813 
    if result.cex is not None:
1814 
      raise result.cex
1815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1816 
 
1817 
  def getBestSellersCount(self, ):
1818 
    self.send_getBestSellersCount()
1819 
    return self.recv_getBestSellersCount()
1820 
 
1821 
  def send_getBestSellersCount(self, ):
1822 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1823 
    args = getBestSellersCount_args()
1824 
    args.write(self._oprot)
1825 
    self._oprot.writeMessageEnd()
1826 
    self._oprot.trans.flush()
1827 
 
1828 
  def recv_getBestSellersCount(self, ):
1829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1830 
    if mtype == TMessageType.EXCEPTION:
1831 
      x = TApplicationException()
1832 
      x.read(self._iprot)
1833 
      self._iprot.readMessageEnd()
1834 
      raise x
1835 
    result = getBestSellersCount_result()
1836 
    result.read(self._iprot)
1837 
    self._iprot.readMessageEnd()
1838 
    if result.success is not None:
1839 
      return result.success
1840 
    if result.cex is not None:
1841 
      raise result.cex
1842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1843 
 
1844 
  def getBestDeals(self, ):
1845 
    self.send_getBestDeals()
1846 
    return self.recv_getBestDeals()
1847 
 
1848 
  def send_getBestDeals(self, ):
1849 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1850 
    args = getBestDeals_args()
1851 
    args.write(self._oprot)
1852 
    self._oprot.writeMessageEnd()
1853 
    self._oprot.trans.flush()
1854 
 
1855 
  def recv_getBestDeals(self, ):
1856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1857 
    if mtype == TMessageType.EXCEPTION:
1858 
      x = TApplicationException()
1859 
      x.read(self._iprot)
1860 
      self._iprot.readMessageEnd()
1861 
      raise x
1862 
    result = getBestDeals_result()
1863 
    result.read(self._iprot)
1864 
    self._iprot.readMessageEnd()
1865 
    if result.success is not None:
1866 
      return result.success
1867 
    if result.isex is not None:
1868 
      raise result.isex
1869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1870 
 
1871 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1872 
    """
1873 
    Parameters:
1874 
     - beginIndex
1875 
     - totalItems
1876 
     - brand
1877 
     - category
1878 
    """
1879 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1880 
    return self.recv_getBestDealsCatalogIds()
1881 
 
1882 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1883 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1884 
    args = getBestDealsCatalogIds_args()
1885 
    args.beginIndex = beginIndex
1886 
    args.totalItems = totalItems
1887 
    args.brand = brand
1888 
    args.category = category
1889 
    args.write(self._oprot)
1890 
    self._oprot.writeMessageEnd()
1891 
    self._oprot.trans.flush()
1892 
 
1893 
  def recv_getBestDealsCatalogIds(self, ):
1894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1895 
    if mtype == TMessageType.EXCEPTION:
1896 
      x = TApplicationException()
1897 
      x.read(self._iprot)
1898 
      self._iprot.readMessageEnd()
1899 
      raise x
1900 
    result = getBestDealsCatalogIds_result()
1901 
    result.read(self._iprot)
1902 
    self._iprot.readMessageEnd()
1903 
    if result.success is not None:
1904 
      return result.success
1905 
    if result.cex is not None:
1906 
      raise result.cex
1907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1908 
 
1909 
  def getBestDealsCount(self, ):
1910 
    self.send_getBestDealsCount()
1911 
    return self.recv_getBestDealsCount()
1912 
 
1913 
  def send_getBestDealsCount(self, ):
1914 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1915 
    args = getBestDealsCount_args()
1916 
    args.write(self._oprot)
1917 
    self._oprot.writeMessageEnd()
1918 
    self._oprot.trans.flush()
1919 
 
1920 
  def recv_getBestDealsCount(self, ):
1921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1922 
    if mtype == TMessageType.EXCEPTION:
1923 
      x = TApplicationException()
1924 
      x.read(self._iprot)
1925 
      self._iprot.readMessageEnd()
1926 
      raise x
1927 
    result = getBestDealsCount_result()
1928 
    result.read(self._iprot)
1929 
    self._iprot.readMessageEnd()
1930 
    if result.success is not None:
1931 
      return result.success
1932 
    if result.cex is not None:
1933 
      raise result.cex
1934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1935 
 
1936 
  def getComingSoon(self, ):
1937 
    self.send_getComingSoon()
1938 
    return self.recv_getComingSoon()
1939 
 
1940 
  def send_getComingSoon(self, ):
1941 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1942 
    args = getComingSoon_args()
1943 
    args.write(self._oprot)
1944 
    self._oprot.writeMessageEnd()
1945 
    self._oprot.trans.flush()
1946 
 
1947 
  def recv_getComingSoon(self, ):
1948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1949 
    if mtype == TMessageType.EXCEPTION:
1950 
      x = TApplicationException()
1951 
      x.read(self._iprot)
1952 
      self._iprot.readMessageEnd()
1953 
      raise x
1954 
    result = getComingSoon_result()
1955 
    result.read(self._iprot)
1956 
    self._iprot.readMessageEnd()
1957 
    if result.success is not None:
1958 
      return result.success
1959 
    if result.isex is not None:
1960 
      raise result.isex
1961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1962 
 
1963 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1964 
    """
1965 
    Parameters:
1966 
     - beginIndex
1967 
     - totalItems
1968 
     - brand
1969 
     - category
1970 
    """
1971 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1972 
    return self.recv_getComingSoonCatalogIds()
1973 
 
1974 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1975 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1976 
    args = getComingSoonCatalogIds_args()
1977 
    args.beginIndex = beginIndex
1978 
    args.totalItems = totalItems
1979 
    args.brand = brand
1980 
    args.category = category
1981 
    args.write(self._oprot)
1982 
    self._oprot.writeMessageEnd()
1983 
    self._oprot.trans.flush()
1984 
 
1985 
  def recv_getComingSoonCatalogIds(self, ):
1986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1987 
    if mtype == TMessageType.EXCEPTION:
1988 
      x = TApplicationException()
1989 
      x.read(self._iprot)
1990 
      self._iprot.readMessageEnd()
1991 
      raise x
1992 
    result = getComingSoonCatalogIds_result()
1993 
    result.read(self._iprot)
1994 
    self._iprot.readMessageEnd()
1995 
    if result.success is not None:
1996 
      return result.success
1997 
    if result.cex is not None:
1998 
      raise result.cex
1999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
2000 
 
2001 
  def getComingSoonCount(self, ):
2002 
    self.send_getComingSoonCount()
2003 
    return self.recv_getComingSoonCount()
2004 
 
2005 
  def send_getComingSoonCount(self, ):
2006 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
2007 
    args = getComingSoonCount_args()
2008 
    args.write(self._oprot)
2009 
    self._oprot.writeMessageEnd()
2010 
    self._oprot.trans.flush()
2011 
 
2012 
  def recv_getComingSoonCount(self, ):
2013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2014 
    if mtype == TMessageType.EXCEPTION:
2015 
      x = TApplicationException()
2016 
      x.read(self._iprot)
2017 
      self._iprot.readMessageEnd()
2018 
      raise x
2019 
    result = getComingSoonCount_result()
2020 
    result.read(self._iprot)
2021 
    self._iprot.readMessageEnd()
2022 
    if result.success is not None:
2023 
      return result.success
2024 
    if result.cex is not None:
2025 
      raise result.cex
2026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
2027 
 
2028 
  def getLatestArrivals(self, ):
2029 
    """
2030 
    Returns a list of items sorted in the descending order by start date.
2031 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
2032 
    """
2033 
    self.send_getLatestArrivals()
2034 
    return self.recv_getLatestArrivals()
2035 
 
2036 
  def send_getLatestArrivals(self, ):
2037 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
2038 
    args = getLatestArrivals_args()
2039 
    args.write(self._oprot)
2040 
    self._oprot.writeMessageEnd()
2041 
    self._oprot.trans.flush()
2042 
 
2043 
  def recv_getLatestArrivals(self, ):
2044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2045 
    if mtype == TMessageType.EXCEPTION:
2046 
      x = TApplicationException()
2047 
      x.read(self._iprot)
2048 
      self._iprot.readMessageEnd()
2049 
      raise x
2050 
    result = getLatestArrivals_result()
2051 
    result.read(self._iprot)
2052 
    self._iprot.readMessageEnd()
2053 
    if result.success is not None:
2054 
      return result.success
2055 
    if result.isex is not None:
2056 
      raise result.isex
2057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
2058 
 
2059 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2060 
    """
2061 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
2062 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
2063 
 
2064 
    Parameters:
2065 
     - beginIndex
2066 
     - totalItems
2067 
     - brand
2068 
     - categories
2069 
    """
2070 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
2071 
    return self.recv_getLatestArrivalsCatalogIds()
2072 
 
2073 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2074 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
2075 
    args = getLatestArrivalsCatalogIds_args()
2076 
    args.beginIndex = beginIndex
2077 
    args.totalItems = totalItems
2078 
    args.brand = brand
2079 
    args.categories = categories
2080 
    args.write(self._oprot)
2081 
    self._oprot.writeMessageEnd()
2082 
    self._oprot.trans.flush()
2083 
 
2084 
  def recv_getLatestArrivalsCatalogIds(self, ):
2085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2086 
    if mtype == TMessageType.EXCEPTION:
2087 
      x = TApplicationException()
2088 
      x.read(self._iprot)
2089 
      self._iprot.readMessageEnd()
2090 
      raise x
2091 
    result = getLatestArrivalsCatalogIds_result()
2092 
    result.read(self._iprot)
2093 
    self._iprot.readMessageEnd()
2094 
    if result.success is not None:
2095 
      return result.success
2096 
    if result.cex is not None:
2097 
      raise result.cex
2098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
2099 
 
2100 
  def getLatestArrivalsCount(self, ):
2101 
    """
2102 
    Get the total number of latest arrivals we are willing to show.
2103 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
2104 
    """
2105 
    self.send_getLatestArrivalsCount()
2106 
    return self.recv_getLatestArrivalsCount()
2107 
 
2108 
  def send_getLatestArrivalsCount(self, ):
2109 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
2110 
    args = getLatestArrivalsCount_args()
2111 
    args.write(self._oprot)
2112 
    self._oprot.writeMessageEnd()
2113 
    self._oprot.trans.flush()
2114 
 
2115 
  def recv_getLatestArrivalsCount(self, ):
2116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2117 
    if mtype == TMessageType.EXCEPTION:
2118 
      x = TApplicationException()
2119 
      x.read(self._iprot)
2120 
      self._iprot.readMessageEnd()
2121 
      raise x
2122 
    result = getLatestArrivalsCount_result()
2123 
    result.read(self._iprot)
2124 
    self._iprot.readMessageEnd()
2125 
    if result.success is not None:
2126 
      return result.success
2127 
    if result.cex is not None:
2128 
      raise result.cex
2129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
2130 
 
2131 
  def generateNewEntityID(self, ):
2132 
    self.send_generateNewEntityID()
2133 
    return self.recv_generateNewEntityID()
2134 
 
2135 
  def send_generateNewEntityID(self, ):
2136 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2137 
    args = generateNewEntityID_args()
2138 
    args.write(self._oprot)
2139 
    self._oprot.writeMessageEnd()
2140 
    self._oprot.trans.flush()
2141 
 
2142 
  def recv_generateNewEntityID(self, ):
2143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2144 
    if mtype == TMessageType.EXCEPTION:
2145 
      x = TApplicationException()
2146 
      x.read(self._iprot)
2147 
      self._iprot.readMessageEnd()
2148 
      raise x
2149 
    result = generateNewEntityID_result()
2150 
    result.read(self._iprot)
2151 
    self._iprot.readMessageEnd()
2152 
    if result.success is not None:
2153 
      return result.success
2154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2155 
 
2156 
  def addCategory(self, category):
2157 
    """
2158 
    All category related functions
2159 
 
2160 
    Parameters:
2161 
     - category
2162 
    """
2163 
    self.send_addCategory(category)
2164 
    return self.recv_addCategory()
2165 
 
2166 
  def send_addCategory(self, category):
2167 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2168 
    args = addCategory_args()
2169 
    args.category = category
2170 
    args.write(self._oprot)
2171 
    self._oprot.writeMessageEnd()
2172 
    self._oprot.trans.flush()
2173 
 
2174 
  def recv_addCategory(self, ):
2175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2176 
    if mtype == TMessageType.EXCEPTION:
2177 
      x = TApplicationException()
2178 
      x.read(self._iprot)
2179 
      self._iprot.readMessageEnd()
2180 
      raise x
2181 
    result = addCategory_result()
2182 
    result.read(self._iprot)
2183 
    self._iprot.readMessageEnd()
2184 
    if result.success is not None:
2185 
      return result.success
2186 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2187 
 
2188 
  def getCategory(self, id):
2189 
    """
2190 
    Parameters:
2191 
     - id
2192 
    """
2193 
    self.send_getCategory(id)
2194 
    return self.recv_getCategory()
2195 
 
2196 
  def send_getCategory(self, id):
2197 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2198 
    args = getCategory_args()
2199 
    args.id = id
2200 
    args.write(self._oprot)
2201 
    self._oprot.writeMessageEnd()
2202 
    self._oprot.trans.flush()
2203 
 
2204 
  def recv_getCategory(self, ):
2205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2206 
    if mtype == TMessageType.EXCEPTION:
2207 
      x = TApplicationException()
2208 
      x.read(self._iprot)
2209 
      self._iprot.readMessageEnd()
2210 
      raise x
2211 
    result = getCategory_result()
2212 
    result.read(self._iprot)
2213 
    self._iprot.readMessageEnd()
2214 
    if result.success is not None:
2215 
      return result.success
2216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2217 
 
2218 
  def getAllCategories(self, ):
2219 
    self.send_getAllCategories()
2220 
    return self.recv_getAllCategories()
2221 
 
2222 
  def send_getAllCategories(self, ):
2223 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2224 
    args = getAllCategories_args()
2225 
    args.write(self._oprot)
2226 
    self._oprot.writeMessageEnd()
2227 
    self._oprot.trans.flush()
2228 
 
2229 
  def recv_getAllCategories(self, ):
2230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2231 
    if mtype == TMessageType.EXCEPTION:
2232 
      x = TApplicationException()
2233 
      x.read(self._iprot)
2234 
      self._iprot.readMessageEnd()
2235 
      raise x
2236 
    result = getAllCategories_result()
2237 
    result.read(self._iprot)
2238 
    self._iprot.readMessageEnd()
2239 
    if result.success is not None:
2240 
      return result.success
2241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2242 
 
2243 
  def getAllSimilarItems(self, itemId):
2244 
    """
2245 
    Returns the list of similar items.
2246 
 
2247 
    Parameters:
2248 
     - itemId
2249 
    """
2250 
    self.send_getAllSimilarItems(itemId)
2251 
    return self.recv_getAllSimilarItems()
2252 
 
2253 
  def send_getAllSimilarItems(self, itemId):
2254 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2255 
    args = getAllSimilarItems_args()
2256 
    args.itemId = itemId
2257 
    args.write(self._oprot)
2258 
    self._oprot.writeMessageEnd()
2259 
    self._oprot.trans.flush()
2260 
 
2261 
  def recv_getAllSimilarItems(self, ):
2262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2263 
    if mtype == TMessageType.EXCEPTION:
2264 
      x = TApplicationException()
2265 
      x.read(self._iprot)
2266 
      self._iprot.readMessageEnd()
2267 
      raise x
2268 
    result = getAllSimilarItems_result()
2269 
    result.read(self._iprot)
2270 
    self._iprot.readMessageEnd()
2271 
    if result.success is not None:
2272 
      return result.success
2273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2274 
 
2275 
  def addSimilarItem(self, itemId, catalogItemId):
2276 
    """
2277 
    Adds similar item.
2278 
 
2279 
    Parameters:
2280 
     - itemId
2281 
     - catalogItemId
2282 
    """
2283 
    self.send_addSimilarItem(itemId, catalogItemId)
2284 
    return self.recv_addSimilarItem()
2285 
 
2286 
  def send_addSimilarItem(self, itemId, catalogItemId):
2287 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2288 
    args = addSimilarItem_args()
2289 
    args.itemId = itemId
2290 
    args.catalogItemId = catalogItemId
2291 
    args.write(self._oprot)
2292 
    self._oprot.writeMessageEnd()
2293 
    self._oprot.trans.flush()
2294 
 
2295 
  def recv_addSimilarItem(self, ):
2296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2297 
    if mtype == TMessageType.EXCEPTION:
2298 
      x = TApplicationException()
2299 
      x.read(self._iprot)
2300 
      self._iprot.readMessageEnd()
2301 
      raise x
2302 
    result = addSimilarItem_result()
2303 
    result.read(self._iprot)
2304 
    self._iprot.readMessageEnd()
2305 
    if result.success is not None:
2306 
      return result.success
2307 
    if result.cex is not None:
2308 
      raise result.cex
2309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2310 
 
6512 kshitij.so 2311 
  def addTag(self, displayName, itemId):
2312 
    """
2313 
    Tag Related
2314 
 
2315 
    Parameters:
2316 
     - displayName
2317 
     - itemId
2318 
    """
2319 
    self.send_addTag(displayName, itemId)
2320 
    return self.recv_addTag()
2321 
 
2322 
  def send_addTag(self, displayName, itemId):
2323 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2324 
    args = addTag_args()
2325 
    args.displayName = displayName
2326 
    args.itemId = itemId
2327 
    args.write(self._oprot)
2328 
    self._oprot.writeMessageEnd()
2329 
    self._oprot.trans.flush()
2330 
 
2331 
  def recv_addTag(self, ):
2332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2333 
    if mtype == TMessageType.EXCEPTION:
2334 
      x = TApplicationException()
2335 
      x.read(self._iprot)
2336 
      self._iprot.readMessageEnd()
2337 
      raise x
2338 
    result = addTag_result()
2339 
    result.read(self._iprot)
2340 
    self._iprot.readMessageEnd()
2341 
    if result.success is not None:
2342 
      return result.success
2343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2344 
 
2345 
  def deleteEntityTag(self, displayName, itemId):
2346 
    """
2347 
    Parameters:
2348 
     - displayName
2349 
     - itemId
2350 
    """
2351 
    self.send_deleteEntityTag(displayName, itemId)
2352 
    return self.recv_deleteEntityTag()
2353 
 
2354 
  def send_deleteEntityTag(self, displayName, itemId):
2355 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2356 
    args = deleteEntityTag_args()
2357 
    args.displayName = displayName
2358 
    args.itemId = itemId
2359 
    args.write(self._oprot)
2360 
    self._oprot.writeMessageEnd()
2361 
    self._oprot.trans.flush()
2362 
 
2363 
  def recv_deleteEntityTag(self, ):
2364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2365 
    if mtype == TMessageType.EXCEPTION:
2366 
      x = TApplicationException()
2367 
      x.read(self._iprot)
2368 
      self._iprot.readMessageEnd()
2369 
      raise x
2370 
    result = deleteEntityTag_result()
2371 
    result.read(self._iprot)
2372 
    self._iprot.readMessageEnd()
2373 
    if result.success is not None:
2374 
      return result.success
2375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2376 
 
2377 
  def deleteTag(self, displayName):
2378 
    """
2379 
    Parameters:
2380 
     - displayName
2381 
    """
2382 
    self.send_deleteTag(displayName)
2383 
    return self.recv_deleteTag()
2384 
 
2385 
  def send_deleteTag(self, displayName):
2386 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2387 
    args = deleteTag_args()
2388 
    args.displayName = displayName
2389 
    args.write(self._oprot)
2390 
    self._oprot.writeMessageEnd()
2391 
    self._oprot.trans.flush()
2392 
 
2393 
  def recv_deleteTag(self, ):
2394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2395 
    if mtype == TMessageType.EXCEPTION:
2396 
      x = TApplicationException()
2397 
      x.read(self._iprot)
2398 
      self._iprot.readMessageEnd()
2399 
      raise x
2400 
    result = deleteTag_result()
2401 
    result.read(self._iprot)
2402 
    self._iprot.readMessageEnd()
2403 
    if result.success is not None:
2404 
      return result.success
2405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2406 
 
2407 
  def getAllTags(self, ):
2408 
    self.send_getAllTags()
2409 
    return self.recv_getAllTags()
2410 
 
2411 
  def send_getAllTags(self, ):
2412 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2413 
    args = getAllTags_args()
2414 
    args.write(self._oprot)
2415 
    self._oprot.writeMessageEnd()
2416 
    self._oprot.trans.flush()
2417 
 
2418 
  def recv_getAllTags(self, ):
2419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2420 
    if mtype == TMessageType.EXCEPTION:
2421 
      x = TApplicationException()
2422 
      x.read(self._iprot)
2423 
      self._iprot.readMessageEnd()
2424 
      raise x
2425 
    result = getAllTags_result()
2426 
    result.read(self._iprot)
2427 
    self._iprot.readMessageEnd()
2428 
    if result.success is not None:
2429 
      return result.success
2430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2431 
 
2432 
  def getAllEntitiesByTagName(self, displayName):
2433 
    """
2434 
    Parameters:
2435 
     - displayName
2436 
    """
2437 
    self.send_getAllEntitiesByTagName(displayName)
2438 
    return self.recv_getAllEntitiesByTagName()
2439 
 
2440 
  def send_getAllEntitiesByTagName(self, displayName):
2441 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2442 
    args = getAllEntitiesByTagName_args()
2443 
    args.displayName = displayName
2444 
    args.write(self._oprot)
2445 
    self._oprot.writeMessageEnd()
2446 
    self._oprot.trans.flush()
2447 
 
2448 
  def recv_getAllEntitiesByTagName(self, ):
2449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2450 
    if mtype == TMessageType.EXCEPTION:
2451 
      x = TApplicationException()
2452 
      x.read(self._iprot)
2453 
      self._iprot.readMessageEnd()
2454 
      raise x
2455 
    result = getAllEntitiesByTagName_result()
2456 
    result.read(self._iprot)
2457 
    self._iprot.readMessageEnd()
2458 
    if result.success is not None:
2459 
      return result.success
2460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2461 
 
6845 amit.gupta 2462 
  def getAllEntityTags(self, ):
2463 
    self.send_getAllEntityTags()
2464 
    return self.recv_getAllEntityTags()
2465 
 
2466 
  def send_getAllEntityTags(self, ):
2467 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2468 
    args = getAllEntityTags_args()
2469 
    args.write(self._oprot)
2470 
    self._oprot.writeMessageEnd()
2471 
    self._oprot.trans.flush()
2472 
 
2473 
  def recv_getAllEntityTags(self, ):
2474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2475 
    if mtype == TMessageType.EXCEPTION:
2476 
      x = TApplicationException()
2477 
      x.read(self._iprot)
2478 
      self._iprot.readMessageEnd()
2479 
      raise x
2480 
    result = getAllEntityTags_result()
2481 
    result.read(self._iprot)
2482 
    self._iprot.readMessageEnd()
2483 
    if result.success is not None:
2484 
      return result.success
2485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2486 
 
8590 kshitij.so 2487 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2488 
    """
8579 kshitij.so 2489 
    Banner Related
2490 
 
6850 kshitij.so 2491 
    Parameters:
8590 kshitij.so 2492 
     - bannerCongregate
6850 kshitij.so 2493 
    """
8590 kshitij.so 2494 
    self.send_addBanner(bannerCongregate)
10097 kshitij.so 2495 
    return self.recv_addBanner()
6850 kshitij.so 2496 
 
8590 kshitij.so 2497 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2498 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2499 
    args = addBanner_args()
8590 kshitij.so 2500 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2501 
    args.write(self._oprot)
2502 
    self._oprot.writeMessageEnd()
2503 
    self._oprot.trans.flush()
2504 
 
2505 
  def recv_addBanner(self, ):
2506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2507 
    if mtype == TMessageType.EXCEPTION:
2508 
      x = TApplicationException()
2509 
      x.read(self._iprot)
2510 
      self._iprot.readMessageEnd()
2511 
      raise x
2512 
    result = addBanner_result()
2513 
    result.read(self._iprot)
2514 
    self._iprot.readMessageEnd()
10097 kshitij.so 2515 
    if result.success is not None:
2516 
      return result.success
2517 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
6850 kshitij.so 2518 
 
8579 kshitij.so 2519 
  def updateBanner(self, banner):
2520 
    """
2521 
    Parameters:
2522 
     - banner
2523 
    """
2524 
    self.send_updateBanner(banner)
2525 
    return self.recv_updateBanner()
2526 
 
2527 
  def send_updateBanner(self, banner):
2528 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2529 
    args = updateBanner_args()
2530 
    args.banner = banner
2531 
    args.write(self._oprot)
2532 
    self._oprot.writeMessageEnd()
2533 
    self._oprot.trans.flush()
2534 
 
2535 
  def recv_updateBanner(self, ):
2536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2537 
    if mtype == TMessageType.EXCEPTION:
2538 
      x = TApplicationException()
2539 
      x.read(self._iprot)
2540 
      self._iprot.readMessageEnd()
2541 
      raise x
2542 
    result = updateBanner_result()
2543 
    result.read(self._iprot)
2544 
    self._iprot.readMessageEnd()
2545 
    if result.success is not None:
2546 
      return result.success
2547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2548 
 
6850 kshitij.so 2549 
  def getAllBanners(self, ):
2550 
    self.send_getAllBanners()
2551 
    return self.recv_getAllBanners()
2552 
 
2553 
  def send_getAllBanners(self, ):
2554 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2555 
    args = getAllBanners_args()
2556 
    args.write(self._oprot)
2557 
    self._oprot.writeMessageEnd()
2558 
    self._oprot.trans.flush()
2559 
 
2560 
  def recv_getAllBanners(self, ):
2561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2562 
    if mtype == TMessageType.EXCEPTION:
2563 
      x = TApplicationException()
2564 
      x.read(self._iprot)
2565 
      self._iprot.readMessageEnd()
2566 
      raise x
2567 
    result = getAllBanners_result()
2568 
    result.read(self._iprot)
2569 
    self._iprot.readMessageEnd()
2570 
    if result.success is not None:
2571 
      return result.success
2572 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2573 
 
9155 kshitij.so 2574 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2575 
    """
2576 
    Parameters:
2577 
     - bannerName
9155 kshitij.so 2578 
     - bannerType
6850 kshitij.so 2579 
    """
9155 kshitij.so 2580 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2581 
    return self.recv_deleteBanner()
2582 
 
9155 kshitij.so 2583 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2584 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2585 
    args = deleteBanner_args()
2586 
    args.bannerName = bannerName
9155 kshitij.so 2587 
    args.bannerType = bannerType
6850 kshitij.so 2588 
    args.write(self._oprot)
2589 
    self._oprot.writeMessageEnd()
2590 
    self._oprot.trans.flush()
2591 
 
2592 
  def recv_deleteBanner(self, ):
2593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2594 
    if mtype == TMessageType.EXCEPTION:
2595 
      x = TApplicationException()
2596 
      x.read(self._iprot)
2597 
      self._iprot.readMessageEnd()
2598 
      raise x
2599 
    result = deleteBanner_result()
2600 
    result.read(self._iprot)
2601 
    self._iprot.readMessageEnd()
2602 
    if result.success is not None:
2603 
      return result.success
2604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2605 
 
9155 kshitij.so 2606 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2607 
    """
2608 
    Parameters:
2609 
     - bannerName
9155 kshitij.so 2610 
     - bannerType
6850 kshitij.so 2611 
    """
9155 kshitij.so 2612 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2613 
    return self.recv_getBannerDetails()
2614 
 
9155 kshitij.so 2615 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2616 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2617 
    args = getBannerDetails_args()
2618 
    args.bannerName = bannerName
9155 kshitij.so 2619 
    args.bannerType = bannerType
6850 kshitij.so 2620 
    args.write(self._oprot)
2621 
    self._oprot.writeMessageEnd()
2622 
    self._oprot.trans.flush()
2623 
 
2624 
  def recv_getBannerDetails(self, ):
2625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2626 
    if mtype == TMessageType.EXCEPTION:
2627 
      x = TApplicationException()
2628 
      x.read(self._iprot)
2629 
      self._iprot.readMessageEnd()
2630 
      raise x
2631 
    result = getBannerDetails_result()
2632 
    result.read(self._iprot)
2633 
    self._iprot.readMessageEnd()
2634 
    if result.success is not None:
2635 
      return result.success
2636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2637 
 
2638 
  def getActiveBanners(self, ):
2639 
    self.send_getActiveBanners()
2640 
    return self.recv_getActiveBanners()
2641 
 
2642 
  def send_getActiveBanners(self, ):
2643 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2644 
    args = getActiveBanners_args()
2645 
    args.write(self._oprot)
2646 
    self._oprot.writeMessageEnd()
2647 
    self._oprot.trans.flush()
2648 
 
2649 
  def recv_getActiveBanners(self, ):
2650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2651 
    if mtype == TMessageType.EXCEPTION:
2652 
      x = TApplicationException()
2653 
      x.read(self._iprot)
2654 
      self._iprot.readMessageEnd()
2655 
      raise x
2656 
    result = getActiveBanners_result()
2657 
    result.read(self._iprot)
2658 
    self._iprot.readMessageEnd()
2659 
    if result.success is not None:
2660 
      return result.success
2661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2662 
 
8579 kshitij.so 2663 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2664 
    """
2665 
    Parameters:
8579 kshitij.so 2666 
     - bannerMaps
6849 kshitij.so 2667 
    """
8579 kshitij.so 2668 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2669 
    return self.recv_addBannerMap()
2670 
 
8579 kshitij.so 2671 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2672 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2673 
    args = addBannerMap_args()
8579 kshitij.so 2674 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2675 
    args.write(self._oprot)
2676 
    self._oprot.writeMessageEnd()
2677 
    self._oprot.trans.flush()
2678 
 
2679 
  def recv_addBannerMap(self, ):
2680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2681 
    if mtype == TMessageType.EXCEPTION:
2682 
      x = TApplicationException()
2683 
      x.read(self._iprot)
2684 
      self._iprot.readMessageEnd()
2685 
      raise x
2686 
    result = addBannerMap_result()
2687 
    result.read(self._iprot)
2688 
    self._iprot.readMessageEnd()
2689 
    if result.success is not None:
2690 
      return result.success
2691 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2692 
 
8579 kshitij.so 2693 
  def updateBannerMap(self, bannerMap):
2694 
    """
2695 
    Parameters:
2696 
     - bannerMap
2697 
    """
2698 
    self.send_updateBannerMap(bannerMap)
2699 
    return self.recv_updateBannerMap()
2700 
 
2701 
  def send_updateBannerMap(self, bannerMap):
2702 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2703 
    args = updateBannerMap_args()
2704 
    args.bannerMap = bannerMap
2705 
    args.write(self._oprot)
2706 
    self._oprot.writeMessageEnd()
2707 
    self._oprot.trans.flush()
2708 
 
2709 
  def recv_updateBannerMap(self, ):
2710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2711 
    if mtype == TMessageType.EXCEPTION:
2712 
      x = TApplicationException()
2713 
      x.read(self._iprot)
2714 
      self._iprot.readMessageEnd()
2715 
      raise x
2716 
    result = updateBannerMap_result()
2717 
    result.read(self._iprot)
2718 
    self._iprot.readMessageEnd()
2719 
    if result.success is not None:
2720 
      return result.success
2721 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2722 
 
6849 kshitij.so 2723 
  def deleteBannerMap(self, bannerName):
2724 
    """
2725 
    Parameters:
2726 
     - bannerName
2727 
    """
2728 
    self.send_deleteBannerMap(bannerName)
2729 
    return self.recv_deleteBannerMap()
2730 
 
2731 
  def send_deleteBannerMap(self, bannerName):
2732 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2733 
    args = deleteBannerMap_args()
2734 
    args.bannerName = bannerName
2735 
    args.write(self._oprot)
2736 
    self._oprot.writeMessageEnd()
2737 
    self._oprot.trans.flush()
2738 
 
2739 
  def recv_deleteBannerMap(self, ):
2740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2741 
    if mtype == TMessageType.EXCEPTION:
2742 
      x = TApplicationException()
2743 
      x.read(self._iprot)
2744 
      self._iprot.readMessageEnd()
2745 
      raise x
2746 
    result = deleteBannerMap_result()
2747 
    result.read(self._iprot)
2748 
    self._iprot.readMessageEnd()
2749 
    if result.success is not None:
2750 
      return result.success
2751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2752 
 
9155 kshitij.so 2753 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2754 
    """
2755 
    Parameters:
2756 
     - bannerName
9155 kshitij.so 2757 
     - bannerType
6849 kshitij.so 2758 
    """
9155 kshitij.so 2759 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2760 
    return self.recv_getBannerMapDetails()
2761 
 
9155 kshitij.so 2762 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2763 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2764 
    args = getBannerMapDetails_args()
2765 
    args.bannerName = bannerName
9155 kshitij.so 2766 
    args.bannerType = bannerType
6849 kshitij.so 2767 
    args.write(self._oprot)
2768 
    self._oprot.writeMessageEnd()
2769 
    self._oprot.trans.flush()
2770 
 
2771 
  def recv_getBannerMapDetails(self, ):
2772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2773 
    if mtype == TMessageType.EXCEPTION:
2774 
      x = TApplicationException()
2775 
      x.read(self._iprot)
2776 
      self._iprot.readMessageEnd()
2777 
      raise x
2778 
    result = getBannerMapDetails_result()
2779 
    result.read(self._iprot)
2780 
    self._iprot.readMessageEnd()
2781 
    if result.success is not None:
2782 
      return result.success
2783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2784 
 
8579 kshitij.so 2785 
  def addBannerUri(self, bannerUriMappings):
2786 
    """
2787 
    Parameters:
2788 
     - bannerUriMappings
2789 
    """
2790 
    self.send_addBannerUri(bannerUriMappings)
2791 
    self.recv_addBannerUri()
2792 
 
2793 
  def send_addBannerUri(self, bannerUriMappings):
2794 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2795 
    args = addBannerUri_args()
2796 
    args.bannerUriMappings = bannerUriMappings
2797 
    args.write(self._oprot)
2798 
    self._oprot.writeMessageEnd()
2799 
    self._oprot.trans.flush()
2800 
 
2801 
  def recv_addBannerUri(self, ):
2802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2803 
    if mtype == TMessageType.EXCEPTION:
2804 
      x = TApplicationException()
2805 
      x.read(self._iprot)
2806 
      self._iprot.readMessageEnd()
2807 
      raise x
2808 
    result = addBannerUri_result()
2809 
    result.read(self._iprot)
2810 
    self._iprot.readMessageEnd()
2811 
    return
2812 
 
9155 kshitij.so 2813 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2814 
    """
2815 
    Parameters:
2816 
     - bannerName
9155 kshitij.so 2817 
     - bannerType
8579 kshitij.so 2818 
    """
9155 kshitij.so 2819 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2820 
    return self.recv_getUriMapping()
2821 
 
9155 kshitij.so 2822 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2823 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2824 
    args = getUriMapping_args()
2825 
    args.bannerName = bannerName
9155 kshitij.so 2826 
    args.bannerType = bannerType
8579 kshitij.so 2827 
    args.write(self._oprot)
2828 
    self._oprot.writeMessageEnd()
2829 
    self._oprot.trans.flush()
2830 
 
2831 
  def recv_getUriMapping(self, ):
2832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2833 
    if mtype == TMessageType.EXCEPTION:
2834 
      x = TApplicationException()
2835 
      x.read(self._iprot)
2836 
      self._iprot.readMessageEnd()
2837 
      raise x
2838 
    result = getUriMapping_result()
2839 
    result.read(self._iprot)
2840 
    self._iprot.readMessageEnd()
2841 
    if result.success is not None:
2842 
      return result.success
2843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2844 
 
2845 
  def addCampaign(self, campaign):
2846 
    """
2847 
    Parameters:
2848 
     - campaign
2849 
    """
2850 
    self.send_addCampaign(campaign)
2851 
    self.recv_addCampaign()
2852 
 
2853 
  def send_addCampaign(self, campaign):
2854 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2855 
    args = addCampaign_args()
2856 
    args.campaign = campaign
2857 
    args.write(self._oprot)
2858 
    self._oprot.writeMessageEnd()
2859 
    self._oprot.trans.flush()
2860 
 
2861 
  def recv_addCampaign(self, ):
2862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2863 
    if mtype == TMessageType.EXCEPTION:
2864 
      x = TApplicationException()
2865 
      x.read(self._iprot)
2866 
      self._iprot.readMessageEnd()
2867 
      raise x
2868 
    result = addCampaign_result()
2869 
    result.read(self._iprot)
2870 
    self._iprot.readMessageEnd()
2871 
    return
2872 
 
2873 
  def getCampaigns(self, campaignName):
2874 
    """
2875 
    Parameters:
2876 
     - campaignName
2877 
    """
2878 
    self.send_getCampaigns(campaignName)
2879 
    return self.recv_getCampaigns()
2880 
 
2881 
  def send_getCampaigns(self, campaignName):
2882 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2883 
    args = getCampaigns_args()
2884 
    args.campaignName = campaignName
2885 
    args.write(self._oprot)
2886 
    self._oprot.writeMessageEnd()
2887 
    self._oprot.trans.flush()
2888 
 
2889 
  def recv_getCampaigns(self, ):
2890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2891 
    if mtype == TMessageType.EXCEPTION:
2892 
      x = TApplicationException()
2893 
      x.read(self._iprot)
2894 
      self._iprot.readMessageEnd()
2895 
      raise x
2896 
    result = getCampaigns_result()
2897 
    result.read(self._iprot)
2898 
    self._iprot.readMessageEnd()
2899 
    if result.success is not None:
2900 
      return result.success
2901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2902 
 
2903 
  def deleteCampaign(self, campaignId):
2904 
    """
2905 
    Parameters:
2906 
     - campaignId
2907 
    """
2908 
    self.send_deleteCampaign(campaignId)
2909 
    self.recv_deleteCampaign()
2910 
 
2911 
  def send_deleteCampaign(self, campaignId):
2912 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2913 
    args = deleteCampaign_args()
2914 
    args.campaignId = campaignId
2915 
    args.write(self._oprot)
2916 
    self._oprot.writeMessageEnd()
2917 
    self._oprot.trans.flush()
2918 
 
2919 
  def recv_deleteCampaign(self, ):
2920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2921 
    if mtype == TMessageType.EXCEPTION:
2922 
      x = TApplicationException()
2923 
      x.read(self._iprot)
2924 
      self._iprot.readMessageEnd()
2925 
      raise x
2926 
    result = deleteCampaign_result()
2927 
    result.read(self._iprot)
2928 
    self._iprot.readMessageEnd()
2929 
    return
2930 
 
2931 
  def getAllCampaigns(self, ):
2932 
    self.send_getAllCampaigns()
2933 
    return self.recv_getAllCampaigns()
2934 
 
2935 
  def send_getAllCampaigns(self, ):
2936 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2937 
    args = getAllCampaigns_args()
2938 
    args.write(self._oprot)
2939 
    self._oprot.writeMessageEnd()
2940 
    self._oprot.trans.flush()
2941 
 
2942 
  def recv_getAllCampaigns(self, ):
2943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2944 
    if mtype == TMessageType.EXCEPTION:
2945 
      x = TApplicationException()
2946 
      x.read(self._iprot)
2947 
      self._iprot.readMessageEnd()
2948 
      raise x
2949 
    result = getAllCampaigns_result()
2950 
    result.read(self._iprot)
2951 
    self._iprot.readMessageEnd()
2952 
    if result.success is not None:
2953 
      return result.success
2954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2955 
 
9155 kshitij.so 2956 
  def getActiveBannersForMobileSite(self, ):
2957 
    self.send_getActiveBannersForMobileSite()
2958 
    return self.recv_getActiveBannersForMobileSite()
2959 
 
2960 
  def send_getActiveBannersForMobileSite(self, ):
2961 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2962 
    args = getActiveBannersForMobileSite_args()
2963 
    args.write(self._oprot)
2964 
    self._oprot.writeMessageEnd()
2965 
    self._oprot.trans.flush()
2966 
 
2967 
  def recv_getActiveBannersForMobileSite(self, ):
2968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2969 
    if mtype == TMessageType.EXCEPTION:
2970 
      x = TApplicationException()
2971 
      x.read(self._iprot)
2972 
      self._iprot.readMessageEnd()
2973 
      raise x
2974 
    result = getActiveBannersForMobileSite_result()
2975 
    result.read(self._iprot)
2976 
    self._iprot.readMessageEnd()
2977 
    if result.success is not None:
2978 
      return result.success
2979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2980 
 
5944 mandeep.dh 2981 
  def deleteSimilarItem(self, itemId, catalogItemId):
2982 
    """
2983 
    Delete similar item.
2984 
 
2985 
    Parameters:
2986 
     - itemId
2987 
     - catalogItemId
2988 
    """
2989 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2990 
    return self.recv_deleteSimilarItem()
2991 
 
2992 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2993 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2994 
    args = deleteSimilarItem_args()
2995 
    args.itemId = itemId
2996 
    args.catalogItemId = catalogItemId
2997 
    args.write(self._oprot)
2998 
    self._oprot.writeMessageEnd()
2999 
    self._oprot.trans.flush()
3000 
 
3001 
  def recv_deleteSimilarItem(self, ):
3002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3003 
    if mtype == TMessageType.EXCEPTION:
3004 
      x = TApplicationException()
3005 
      x.read(self._iprot)
3006 
      self._iprot.readMessageEnd()
3007 
      raise x
3008 
    result = deleteSimilarItem_result()
3009 
    result.read(self._iprot)
3010 
    self._iprot.readMessageEnd()
3011 
    if result.success is not None:
3012 
      return result.success
3013 
    if result.cex is not None:
3014 
      raise result.cex
3015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
3016 
 
3017 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
3018 
    """
3019 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
3020 
    If yes, returns the itemId else returns 0
3021 
 
3022 
    Parameters:
3023 
     - brand
3024 
     - modelNumber
3025 
     - modelName
3026 
     - color
3027 
    """
3028 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
3029 
    return self.recv_checkSimilarItem()
3030 
 
3031 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
3032 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
3033 
    args = checkSimilarItem_args()
3034 
    args.brand = brand
3035 
    args.modelNumber = modelNumber
3036 
    args.modelName = modelName
3037 
    args.color = color
3038 
    args.write(self._oprot)
3039 
    self._oprot.writeMessageEnd()
3040 
    self._oprot.trans.flush()
3041 
 
3042 
  def recv_checkSimilarItem(self, ):
3043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3044 
    if mtype == TMessageType.EXCEPTION:
3045 
      x = TApplicationException()
3046 
      x.read(self._iprot)
3047 
      self._iprot.readMessageEnd()
3048 
      raise x
3049 
    result = checkSimilarItem_result()
3050 
    result.read(self._iprot)
3051 
    self._iprot.readMessageEnd()
3052 
    if result.success is not None:
3053 
      return result.success
3054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
3055 
 
3056 
  def validateRiskyStatus(self, itemId):
3057 
    """
3058 
    Check wether item is risky and change status if inventory is not available for risky items
3059 
 
3060 
    Parameters:
3061 
     - itemId
3062 
    """
3063 
    self.send_validateRiskyStatus(itemId)
3064 
    self.recv_validateRiskyStatus()
3065 
 
3066 
  def send_validateRiskyStatus(self, itemId):
3067 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
3068 
    args = validateRiskyStatus_args()
3069 
    args.itemId = itemId
3070 
    args.write(self._oprot)
3071 
    self._oprot.writeMessageEnd()
3072 
    self._oprot.trans.flush()
3073 
 
3074 
  def recv_validateRiskyStatus(self, ):
3075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3076 
    if mtype == TMessageType.EXCEPTION:
3077 
      x = TApplicationException()
3078 
      x.read(self._iprot)
3079 
      self._iprot.readMessageEnd()
3080 
      raise x
3081 
    result = validateRiskyStatus_result()
3082 
    result.read(self._iprot)
3083 
    self._iprot.readMessageEnd()
3084 
    return
3085 
 
3086 
  def changeItemRiskyFlag(self, itemId, risky):
3087 
    """
3088 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
3089 
 
3090 
    Parameters:
3091 
     - itemId
3092 
     - risky
3093 
    """
3094 
    self.send_changeItemRiskyFlag(itemId, risky)
3095 
    self.recv_changeItemRiskyFlag()
3096 
 
3097 
  def send_changeItemRiskyFlag(self, itemId, risky):
3098 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
3099 
    args = changeItemRiskyFlag_args()
3100 
    args.itemId = itemId
3101 
    args.risky = risky
3102 
    args.write(self._oprot)
3103 
    self._oprot.writeMessageEnd()
3104 
    self._oprot.trans.flush()
3105 
 
3106 
  def recv_changeItemRiskyFlag(self, ):
3107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3108 
    if mtype == TMessageType.EXCEPTION:
3109 
      x = TApplicationException()
3110 
      x.read(self._iprot)
3111 
      self._iprot.readMessageEnd()
3112 
      raise x
3113 
    result = changeItemRiskyFlag_result()
3114 
    result.read(self._iprot)
3115 
    self._iprot.readMessageEnd()
3116 
    return
3117 
 
3118 
  def getItemsByRiskyFlag(self, ):
3119 
    """
3120 
    Returns list of items marked as risky.
3121 
    """
3122 
    self.send_getItemsByRiskyFlag()
3123 
    return self.recv_getItemsByRiskyFlag()
3124 
 
3125 
  def send_getItemsByRiskyFlag(self, ):
3126 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
3127 
    args = getItemsByRiskyFlag_args()
3128 
    args.write(self._oprot)
3129 
    self._oprot.writeMessageEnd()
3130 
    self._oprot.trans.flush()
3131 
 
3132 
  def recv_getItemsByRiskyFlag(self, ):
3133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3134 
    if mtype == TMessageType.EXCEPTION:
3135 
      x = TApplicationException()
3136 
      x.read(self._iprot)
3137 
      self._iprot.readMessageEnd()
3138 
      raise x
3139 
    result = getItemsByRiskyFlag_result()
3140 
    result.read(self._iprot)
3141 
    self._iprot.readMessageEnd()
3142 
    if result.success is not None:
3143 
      return result.success
3144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
3145 
 
3146 
  def getItemsForMasterSheet(self, category, brand):
3147 
    """
3148 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3149 
 
3150 
    Parameters:
3151 
     - category
3152 
     - brand
3153 
    """
3154 
    self.send_getItemsForMasterSheet(category, brand)
3155 
    return self.recv_getItemsForMasterSheet()
3156 
 
3157 
  def send_getItemsForMasterSheet(self, category, brand):
3158 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3159 
    args = getItemsForMasterSheet_args()
3160 
    args.category = category
3161 
    args.brand = brand
3162 
    args.write(self._oprot)
3163 
    self._oprot.writeMessageEnd()
3164 
    self._oprot.trans.flush()
3165 
 
3166 
  def recv_getItemsForMasterSheet(self, ):
3167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3168 
    if mtype == TMessageType.EXCEPTION:
3169 
      x = TApplicationException()
3170 
      x.read(self._iprot)
3171 
      self._iprot.readMessageEnd()
3172 
      raise x
3173 
    result = getItemsForMasterSheet_result()
3174 
    result.read(self._iprot)
3175 
    self._iprot.readMessageEnd()
3176 
    if result.success is not None:
3177 
      return result.success
3178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3179 
 
3180 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3181 
    """
3182 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3183 
 
3184 
    Parameters:
3185 
     - beginIndex
3186 
     - totalItems
3187 
     - itemId
3188 
    """
3189 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3190 
    return self.recv_getSimilarItemsCatalogIds()
3191 
 
3192 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3193 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3194 
    args = getSimilarItemsCatalogIds_args()
3195 
    args.beginIndex = beginIndex
3196 
    args.totalItems = totalItems
3197 
    args.itemId = itemId
3198 
    args.write(self._oprot)
3199 
    self._oprot.writeMessageEnd()
3200 
    self._oprot.trans.flush()
3201 
 
3202 
  def recv_getSimilarItemsCatalogIds(self, ):
3203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3204 
    if mtype == TMessageType.EXCEPTION:
3205 
      x = TApplicationException()
3206 
      x.read(self._iprot)
3207 
      self._iprot.readMessageEnd()
3208 
      raise x
3209 
    result = getSimilarItemsCatalogIds_result()
3210 
    result.read(self._iprot)
3211 
    self._iprot.readMessageEnd()
3212 
    if result.success is not None:
3213 
      return result.success
3214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3215 
 
3216 
  def addProductNotification(self, itemId, email):
3217 
    """
3218 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3219 
 
3220 
    Parameters:
3221 
     - itemId
3222 
     - email
3223 
    """
3224 
    self.send_addProductNotification(itemId, email)
3225 
    return self.recv_addProductNotification()
3226 
 
3227 
  def send_addProductNotification(self, itemId, email):
3228 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3229 
    args = addProductNotification_args()
3230 
    args.itemId = itemId
3231 
    args.email = email
3232 
    args.write(self._oprot)
3233 
    self._oprot.writeMessageEnd()
3234 
    self._oprot.trans.flush()
3235 
 
3236 
  def recv_addProductNotification(self, ):
3237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3238 
    if mtype == TMessageType.EXCEPTION:
3239 
      x = TApplicationException()
3240 
      x.read(self._iprot)
3241 
      self._iprot.readMessageEnd()
3242 
      raise x
3243 
    result = addProductNotification_result()
3244 
    result.read(self._iprot)
3245 
    self._iprot.readMessageEnd()
3246 
    if result.success is not None:
3247 
      return result.success
3248 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3249 
 
3250 
  def sendProductNotifications(self, ):
3251 
    """
3252 
    Send the product notifications to the users for items which has stock.
3253 
    """
3254 
    self.send_sendProductNotifications()
3255 
    return self.recv_sendProductNotifications()
3256 
 
3257 
  def send_sendProductNotifications(self, ):
3258 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3259 
    args = sendProductNotifications_args()
3260 
    args.write(self._oprot)
3261 
    self._oprot.writeMessageEnd()
3262 
    self._oprot.trans.flush()
3263 
 
3264 
  def recv_sendProductNotifications(self, ):
3265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3266 
    if mtype == TMessageType.EXCEPTION:
3267 
      x = TApplicationException()
3268 
      x.read(self._iprot)
3269 
      self._iprot.readMessageEnd()
3270 
      raise x
3271 
    result = sendProductNotifications_result()
3272 
    result.read(self._iprot)
3273 
    self._iprot.readMessageEnd()
3274 
    if result.success is not None:
3275 
      return result.success
3276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3277 
 
3278 
  def getAllBrandsByCategory(self, categoryId):
3279 
    """
3280 
    Returns list of brand names for a given category Id
3281 
 
3282 
    Parameters:
3283 
     - categoryId
3284 
    """
3285 
    self.send_getAllBrandsByCategory(categoryId)
3286 
    return self.recv_getAllBrandsByCategory()
3287 
 
3288 
  def send_getAllBrandsByCategory(self, categoryId):
3289 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3290 
    args = getAllBrandsByCategory_args()
3291 
    args.categoryId = categoryId
3292 
    args.write(self._oprot)
3293 
    self._oprot.writeMessageEnd()
3294 
    self._oprot.trans.flush()
3295 
 
3296 
  def recv_getAllBrandsByCategory(self, ):
3297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3298 
    if mtype == TMessageType.EXCEPTION:
3299 
      x = TApplicationException()
3300 
      x.read(self._iprot)
3301 
      self._iprot.readMessageEnd()
3302 
      raise x
3303 
    result = getAllBrandsByCategory_result()
3304 
    result.read(self._iprot)
3305 
    self._iprot.readMessageEnd()
3306 
    if result.success is not None:
3307 
      return result.success
3308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3309 
 
3310 
  def getAllBrands(self, ):
3311 
    """
3312 
    Returns list of brand names
3313 
    """
3314 
    self.send_getAllBrands()
3315 
    return self.recv_getAllBrands()
3316 
 
3317 
  def send_getAllBrands(self, ):
3318 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3319 
    args = getAllBrands_args()
3320 
    args.write(self._oprot)
3321 
    self._oprot.writeMessageEnd()
3322 
    self._oprot.trans.flush()
3323 
 
3324 
  def recv_getAllBrands(self, ):
3325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3326 
    if mtype == TMessageType.EXCEPTION:
3327 
      x = TApplicationException()
3328 
      x.read(self._iprot)
3329 
      self._iprot.readMessageEnd()
3330 
      raise x
3331 
    result = getAllBrands_result()
3332 
    result.read(self._iprot)
3333 
    self._iprot.readMessageEnd()
3334 
    if result.success is not None:
3335 
      return result.success
3336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3337 
 
3338 
  def getAllSources(self, ):
3339 
    """
3340 
    Return list of all sources
3341 
    """
3342 
    self.send_getAllSources()
3343 
    return self.recv_getAllSources()
3344 
 
3345 
  def send_getAllSources(self, ):
3346 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3347 
    args = getAllSources_args()
3348 
    args.write(self._oprot)
3349 
    self._oprot.writeMessageEnd()
3350 
    self._oprot.trans.flush()
3351 
 
3352 
  def recv_getAllSources(self, ):
3353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3354 
    if mtype == TMessageType.EXCEPTION:
3355 
      x = TApplicationException()
3356 
      x.read(self._iprot)
3357 
      self._iprot.readMessageEnd()
3358 
      raise x
3359 
    result = getAllSources_result()
3360 
    result.read(self._iprot)
3361 
    self._iprot.readMessageEnd()
3362 
    if result.success is not None:
3363 
      return result.success
3364 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3365 
 
3366 
  def getItemPricingBySource(self, itemId, sourceId):
3367 
    """
3368 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3369 
 
3370 
    Parameters:
3371 
     - itemId
3372 
     - sourceId
3373 
    """
3374 
    self.send_getItemPricingBySource(itemId, sourceId)
3375 
    return self.recv_getItemPricingBySource()
3376 
 
3377 
  def send_getItemPricingBySource(self, itemId, sourceId):
3378 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3379 
    args = getItemPricingBySource_args()
3380 
    args.itemId = itemId
3381 
    args.sourceId = sourceId
3382 
    args.write(self._oprot)
3383 
    self._oprot.writeMessageEnd()
3384 
    self._oprot.trans.flush()
3385 
 
3386 
  def recv_getItemPricingBySource(self, ):
3387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3388 
    if mtype == TMessageType.EXCEPTION:
3389 
      x = TApplicationException()
3390 
      x.read(self._iprot)
3391 
      self._iprot.readMessageEnd()
3392 
      raise x
3393 
    result = getItemPricingBySource_result()
3394 
    result.read(self._iprot)
3395 
    self._iprot.readMessageEnd()
3396 
    if result.success is not None:
3397 
      return result.success
3398 
    if result.cex is not None:
3399 
      raise result.cex
3400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3401 
 
3402 
  def addSourceItemPricing(self, sourceItemPricing):
3403 
    """
3404 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3405 
    If item is not found or source is not found, it will throw exception.
3406 
 
3407 
    Parameters:
3408 
     - sourceItemPricing
3409 
    """
3410 
    self.send_addSourceItemPricing(sourceItemPricing)
3411 
    self.recv_addSourceItemPricing()
3412 
 
3413 
  def send_addSourceItemPricing(self, sourceItemPricing):
3414 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3415 
    args = addSourceItemPricing_args()
3416 
    args.sourceItemPricing = sourceItemPricing
3417 
    args.write(self._oprot)
3418 
    self._oprot.writeMessageEnd()
3419 
    self._oprot.trans.flush()
3420 
 
3421 
  def recv_addSourceItemPricing(self, ):
3422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3423 
    if mtype == TMessageType.EXCEPTION:
3424 
      x = TApplicationException()
3425 
      x.read(self._iprot)
3426 
      self._iprot.readMessageEnd()
3427 
      raise x
3428 
    result = addSourceItemPricing_result()
3429 
    result.read(self._iprot)
3430 
    self._iprot.readMessageEnd()
3431 
    if result.cex is not None:
3432 
      raise result.cex
3433 
    return
3434 
 
3435 
  def getAllSourcePricing(self, itemId):
3436 
    """
3437 
    Returns the list of source pricing information of an item.
3438 
    Raises an exception if item not found corresponding to itemId
3439 
 
3440 
    Parameters:
3441 
     - itemId
3442 
    """
3443 
    self.send_getAllSourcePricing(itemId)
3444 
    return self.recv_getAllSourcePricing()
3445 
 
3446 
  def send_getAllSourcePricing(self, itemId):
3447 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3448 
    args = getAllSourcePricing_args()
3449 
    args.itemId = itemId
3450 
    args.write(self._oprot)
3451 
    self._oprot.writeMessageEnd()
3452 
    self._oprot.trans.flush()
3453 
 
3454 
  def recv_getAllSourcePricing(self, ):
3455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3456 
    if mtype == TMessageType.EXCEPTION:
3457 
      x = TApplicationException()
3458 
      x.read(self._iprot)
3459 
      self._iprot.readMessageEnd()
3460 
      raise x
3461 
    result = getAllSourcePricing_result()
3462 
    result.read(self._iprot)
3463 
    self._iprot.readMessageEnd()
3464 
    if result.success is not None:
3465 
      return result.success
3466 
    if result.cex is not None:
3467 
      raise result.cex
3468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3469 
 
3470 
  def getItemForSource(self, item_id, sourceId):
3471 
    """
3472 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3473 
 
3474 
    Parameters:
3475 
     - item_id
3476 
     - sourceId
3477 
    """
3478 
    self.send_getItemForSource(item_id, sourceId)
3479 
    return self.recv_getItemForSource()
3480 
 
3481 
  def send_getItemForSource(self, item_id, sourceId):
3482 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3483 
    args = getItemForSource_args()
3484 
    args.item_id = item_id
3485 
    args.sourceId = sourceId
3486 
    args.write(self._oprot)
3487 
    self._oprot.writeMessageEnd()
3488 
    self._oprot.trans.flush()
3489 
 
3490 
  def recv_getItemForSource(self, ):
3491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3492 
    if mtype == TMessageType.EXCEPTION:
3493 
      x = TApplicationException()
3494 
      x.read(self._iprot)
3495 
      self._iprot.readMessageEnd()
3496 
      raise x
3497 
    result = getItemForSource_result()
3498 
    result.read(self._iprot)
3499 
    self._iprot.readMessageEnd()
3500 
    if result.success is not None:
3501 
      return result.success
3502 
    if result.cex is not None:
3503 
      raise result.cex
3504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3505 
 
3506 
  def searchItemsInRange(self, searchTerms, offset, limit):
3507 
    """
3508 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3509 
 
3510 
    Parameters:
3511 
     - searchTerms
3512 
     - offset
3513 
     - limit
3514 
    """
3515 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3516 
    return self.recv_searchItemsInRange()
3517 
 
3518 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3519 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3520 
    args = searchItemsInRange_args()
3521 
    args.searchTerms = searchTerms
3522 
    args.offset = offset
3523 
    args.limit = limit
3524 
    args.write(self._oprot)
3525 
    self._oprot.writeMessageEnd()
3526 
    self._oprot.trans.flush()
3527 
 
3528 
  def recv_searchItemsInRange(self, ):
3529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3530 
    if mtype == TMessageType.EXCEPTION:
3531 
      x = TApplicationException()
3532 
      x.read(self._iprot)
3533 
      self._iprot.readMessageEnd()
3534 
      raise x
3535 
    result = searchItemsInRange_result()
3536 
    result.read(self._iprot)
3537 
    self._iprot.readMessageEnd()
3538 
    if result.success is not None:
3539 
      return result.success
3540 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3541 
 
3542 
  def getSearchResultCount(self, searchTerms):
3543 
    """
3544 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3545 
 
3546 
    Parameters:
3547 
     - searchTerms
3548 
    """
3549 
    self.send_getSearchResultCount(searchTerms)
3550 
    return self.recv_getSearchResultCount()
3551 
 
3552 
  def send_getSearchResultCount(self, searchTerms):
3553 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3554 
    args = getSearchResultCount_args()
3555 
    args.searchTerms = searchTerms
3556 
    args.write(self._oprot)
3557 
    self._oprot.writeMessageEnd()
3558 
    self._oprot.trans.flush()
3559 
 
3560 
  def recv_getSearchResultCount(self, ):
3561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3562 
    if mtype == TMessageType.EXCEPTION:
3563 
      x = TApplicationException()
3564 
      x.read(self._iprot)
3565 
      self._iprot.readMessageEnd()
3566 
      raise x
3567 
    result = getSearchResultCount_result()
3568 
    result.read(self._iprot)
3569 
    self._iprot.readMessageEnd()
3570 
    if result.success is not None:
3571 
      return result.success
3572 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3573 
 
3574 
  def getProductNotifications(self, startDateTime):
3575 
    """
3576 
    Returns a list of product notifications added after a supplied datetime
3577 
 
3578 
    Parameters:
3579 
     - startDateTime
3580 
    """
3581 
    self.send_getProductNotifications(startDateTime)
3582 
    return self.recv_getProductNotifications()
3583 
 
3584 
  def send_getProductNotifications(self, startDateTime):
3585 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3586 
    args = getProductNotifications_args()
3587 
    args.startDateTime = startDateTime
3588 
    args.write(self._oprot)
3589 
    self._oprot.writeMessageEnd()
3590 
    self._oprot.trans.flush()
3591 
 
3592 
  def recv_getProductNotifications(self, ):
3593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3594 
    if mtype == TMessageType.EXCEPTION:
3595 
      x = TApplicationException()
3596 
      x.read(self._iprot)
3597 
      self._iprot.readMessageEnd()
3598 
      raise x
3599 
    result = getProductNotifications_result()
3600 
    result.read(self._iprot)
3601 
    self._iprot.readMessageEnd()
3602 
    if result.success is not None:
3603 
      return result.success
3604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3605 
 
7897 amar.kumar 3606 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3607 
    """
3608 
    Returns a list of count of requests for product notification against each item
3609 
 
3610 
    Parameters:
3611 
     - startDateTime
7897 amar.kumar 3612 
     - categoryId
5944 mandeep.dh 3613 
    """
7897 amar.kumar 3614 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3615 
    return self.recv_getProductNotificationRequestCount()
3616 
 
7897 amar.kumar 3617 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3618 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3619 
    args = getProductNotificationRequestCount_args()
3620 
    args.startDateTime = startDateTime
7897 amar.kumar 3621 
    args.categoryId = categoryId
5944 mandeep.dh 3622 
    args.write(self._oprot)
3623 
    self._oprot.writeMessageEnd()
3624 
    self._oprot.trans.flush()
3625 
 
3626 
  def recv_getProductNotificationRequestCount(self, ):
3627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3628 
    if mtype == TMessageType.EXCEPTION:
3629 
      x = TApplicationException()
3630 
      x.read(self._iprot)
3631 
      self._iprot.readMessageEnd()
3632 
      raise x
3633 
    result = getProductNotificationRequestCount_result()
3634 
    result.read(self._iprot)
3635 
    self._iprot.readMessageEnd()
3636 
    if result.success is not None:
3637 
      return result.success
3638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3639 
 
3640 
  def addAuthorizationLog(self, itemId, username, reason):
3641 
    """
3642 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3643 
 
3644 
    Parameters:
3645 
     - itemId
3646 
     - username
3647 
     - reason
3648 
    """
3649 
    self.send_addAuthorizationLog(itemId, username, reason)
3650 
    return self.recv_addAuthorizationLog()
3651 
 
3652 
  def send_addAuthorizationLog(self, itemId, username, reason):
3653 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3654 
    args = addAuthorizationLog_args()
3655 
    args.itemId = itemId
3656 
    args.username = username
3657 
    args.reason = reason
3658 
    args.write(self._oprot)
3659 
    self._oprot.writeMessageEnd()
3660 
    self._oprot.trans.flush()
3661 
 
3662 
  def recv_addAuthorizationLog(self, ):
3663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3664 
    if mtype == TMessageType.EXCEPTION:
3665 
      x = TApplicationException()
3666 
      x.read(self._iprot)
3667 
      self._iprot.readMessageEnd()
3668 
      raise x
3669 
    result = addAuthorizationLog_result()
3670 
    result.read(self._iprot)
3671 
    self._iprot.readMessageEnd()
3672 
    if result.success is not None:
3673 
      return result.success
3674 
    if result.cex is not None:
3675 
      raise result.cex
3676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3677 
 
3678 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3679 
    """
3680 
    Parameters:
3681 
     - catalog_item_id
3682 
     - voucherType
3683 
     - voucherAmount
3684 
    """
3685 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3686 
    return self.recv_addupdateVoucherForItem()
3687 
 
3688 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3689 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3690 
    args = addupdateVoucherForItem_args()
3691 
    args.catalog_item_id = catalog_item_id
3692 
    args.voucherType = voucherType
3693 
    args.voucherAmount = voucherAmount
3694 
    args.write(self._oprot)
3695 
    self._oprot.writeMessageEnd()
3696 
    self._oprot.trans.flush()
3697 
 
3698 
  def recv_addupdateVoucherForItem(self, ):
3699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3700 
    if mtype == TMessageType.EXCEPTION:
3701 
      x = TApplicationException()
3702 
      x.read(self._iprot)
3703 
      self._iprot.readMessageEnd()
3704 
      raise x
3705 
    result = addupdateVoucherForItem_result()
3706 
    result.read(self._iprot)
3707 
    self._iprot.readMessageEnd()
3708 
    if result.success is not None:
3709 
      return result.success
3710 
    if result.cex is not None:
3711 
      raise result.cex
3712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3713 
 
3714 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3715 
    """
3716 
    Parameters:
3717 
     - catalog_item_id
3718 
     - voucherType
3719 
    """
3720 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3721 
    return self.recv_deleteVoucherForItem()
3722 
 
3723 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3724 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3725 
    args = deleteVoucherForItem_args()
3726 
    args.catalog_item_id = catalog_item_id
3727 
    args.voucherType = voucherType
3728 
    args.write(self._oprot)
3729 
    self._oprot.writeMessageEnd()
3730 
    self._oprot.trans.flush()
3731 
 
3732 
  def recv_deleteVoucherForItem(self, ):
3733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3734 
    if mtype == TMessageType.EXCEPTION:
3735 
      x = TApplicationException()
3736 
      x.read(self._iprot)
3737 
      self._iprot.readMessageEnd()
3738 
      raise x
3739 
    result = deleteVoucherForItem_result()
3740 
    result.read(self._iprot)
3741 
    self._iprot.readMessageEnd()
3742 
    if result.success is not None:
3743 
      return result.success
3744 
    if result.cex is not None:
3745 
      raise result.cex
3746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3747 
 
3748 
  def getVoucherAmount(self, itemId, voucherType):
3749 
    """
3750 
    Parameters:
3751 
     - itemId
3752 
     - voucherType
3753 
    """
3754 
    self.send_getVoucherAmount(itemId, voucherType)
3755 
    return self.recv_getVoucherAmount()
3756 
 
3757 
  def send_getVoucherAmount(self, itemId, voucherType):
3758 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3759 
    args = getVoucherAmount_args()
3760 
    args.itemId = itemId
3761 
    args.voucherType = voucherType
3762 
    args.write(self._oprot)
3763 
    self._oprot.writeMessageEnd()
3764 
    self._oprot.trans.flush()
3765 
 
3766 
  def recv_getVoucherAmount(self, ):
3767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3768 
    if mtype == TMessageType.EXCEPTION:
3769 
      x = TApplicationException()
3770 
      x.read(self._iprot)
3771 
      self._iprot.readMessageEnd()
3772 
      raise x
3773 
    result = getVoucherAmount_result()
3774 
    result.read(self._iprot)
3775 
    self._iprot.readMessageEnd()
3776 
    if result.success is not None:
3777 
      return result.success
3778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3779 
 
3780 
  def getAllItemVouchers(self, itemId):
3781 
    """
3782 
    Parameters:
3783 
     - itemId
3784 
    """
3785 
    self.send_getAllItemVouchers(itemId)
3786 
    return self.recv_getAllItemVouchers()
3787 
 
3788 
  def send_getAllItemVouchers(self, itemId):
3789 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3790 
    args = getAllItemVouchers_args()
3791 
    args.itemId = itemId
3792 
    args.write(self._oprot)
3793 
    self._oprot.writeMessageEnd()
3794 
    self._oprot.trans.flush()
3795 
 
3796 
  def recv_getAllItemVouchers(self, ):
3797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3798 
    if mtype == TMessageType.EXCEPTION:
3799 
      x = TApplicationException()
3800 
      x.read(self._iprot)
3801 
      self._iprot.readMessageEnd()
3802 
      raise x
3803 
    result = getAllItemVouchers_result()
3804 
    result.read(self._iprot)
3805 
    self._iprot.readMessageEnd()
3806 
    if result.success is not None:
3807 
      return result.success
3808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3809 
 
3810 
  def isValidCatalogItemId(self, catalog_item_id):
3811 
    """
3812 
    Parameters:
3813 
     - catalog_item_id
3814 
    """
3815 
    self.send_isValidCatalogItemId(catalog_item_id)
3816 
    return self.recv_isValidCatalogItemId()
3817 
 
3818 
  def send_isValidCatalogItemId(self, catalog_item_id):
3819 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3820 
    args = isValidCatalogItemId_args()
3821 
    args.catalog_item_id = catalog_item_id
3822 
    args.write(self._oprot)
3823 
    self._oprot.writeMessageEnd()
3824 
    self._oprot.trans.flush()
3825 
 
3826 
  def recv_isValidCatalogItemId(self, ):
3827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3828 
    if mtype == TMessageType.EXCEPTION:
3829 
      x = TApplicationException()
3830 
      x.read(self._iprot)
3831 
      self._iprot.readMessageEnd()
3832 
      raise x
3833 
    result = isValidCatalogItemId_result()
3834 
    result.read(self._iprot)
3835 
    self._iprot.readMessageEnd()
3836 
    if result.success is not None:
3837 
      return result.success
3838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3839 
 
7330 amit.gupta 3840 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3841 
    """
3842 
    Parameters:
3843 
     - itemId
7330 amit.gupta 3844 
     - stateId
6039 amit.gupta 3845 
     - price
3846 
    """
7330 amit.gupta 3847 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3848 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3849 
 
7330 amit.gupta 3850 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3851 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3852 
    args = getVatPercentageForItem_args()
3853 
    args.itemId = itemId
7330 amit.gupta 3854 
    args.stateId = stateId
6039 amit.gupta 3855 
    args.price = price
3856 
    args.write(self._oprot)
3857 
    self._oprot.writeMessageEnd()
3858 
    self._oprot.trans.flush()
3859 
 
3860 
  def recv_getVatPercentageForItem(self, ):
3861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3862 
    if mtype == TMessageType.EXCEPTION:
3863 
      x = TApplicationException()
3864 
      x.read(self._iprot)
3865 
      self._iprot.readMessageEnd()
3866 
      raise x
3867 
    result = getVatPercentageForItem_result()
3868 
    result.read(self._iprot)
3869 
    self._iprot.readMessageEnd()
3870 
    if result.success is not None:
3871 
      return result.success
7340 amit.gupta 3872 
    if result.cex is not None:
3873 
      raise result.cex
6039 amit.gupta 3874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3875 
 
3876 
  def getVatAmountForItem(self, itemId, price):
3877 
    """
3878 
    Parameters:
3879 
     - itemId
3880 
     - price
3881 
    """
3882 
    self.send_getVatAmountForItem(itemId, price)
3883 
    return self.recv_getVatAmountForItem()
3884 
 
3885 
  def send_getVatAmountForItem(self, itemId, price):
3886 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3887 
    args = getVatAmountForItem_args()
3888 
    args.itemId = itemId
3889 
    args.price = price
3890 
    args.write(self._oprot)
3891 
    self._oprot.writeMessageEnd()
3892 
    self._oprot.trans.flush()
3893 
 
3894 
  def recv_getVatAmountForItem(self, ):
3895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3896 
    if mtype == TMessageType.EXCEPTION:
3897 
      x = TApplicationException()
3898 
      x.read(self._iprot)
3899 
      self._iprot.readMessageEnd()
3900 
      raise x
3901 
    result = getVatAmountForItem_result()
3902 
    result.read(self._iprot)
3903 
    self._iprot.readMessageEnd()
3904 
    if result.success is not None:
3905 
      return result.success
3906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3907 
 
6531 vikram.rag 3908 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3909 
    """
3910 
    Parameters:
3911 
     - offset
3912 
     - limit
3913 
    """
3914 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3915 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3916 
 
6531 vikram.rag 3917 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3918 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3919 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3920 
    args.offset = offset
3921 
    args.limit = limit
3922 
    args.write(self._oprot)
3923 
    self._oprot.writeMessageEnd()
3924 
    self._oprot.trans.flush()
3925 
 
3926 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3928 
    if mtype == TMessageType.EXCEPTION:
3929 
      x = TApplicationException()
3930 
      x.read(self._iprot)
3931 
      self._iprot.readMessageEnd()
3932 
      raise x
3933 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3934 
    result.read(self._iprot)
3935 
    self._iprot.readMessageEnd()
3936 
    if result.success is not None:
3937 
      return result.success
3938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3939 
 
6821 amar.kumar 3940 
  def getAllAliveItems(self, ):
3941 
    self.send_getAllAliveItems()
3942 
    return self.recv_getAllAliveItems()
3943 
 
3944 
  def send_getAllAliveItems(self, ):
3945 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3946 
    args = getAllAliveItems_args()
3947 
    args.write(self._oprot)
3948 
    self._oprot.writeMessageEnd()
3949 
    self._oprot.trans.flush()
3950 
 
3951 
  def recv_getAllAliveItems(self, ):
3952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3953 
    if mtype == TMessageType.EXCEPTION:
3954 
      x = TApplicationException()
3955 
      x.read(self._iprot)
3956 
      self._iprot.readMessageEnd()
3957 
      raise x
3958 
    result = getAllAliveItems_result()
3959 
    result.read(self._iprot)
3960 
    self._iprot.readMessageEnd()
3961 
    if result.success is not None:
3962 
      return result.success
3963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3964 
 
6921 anupam.sin 3965 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3966 
    """
3967 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3968 
 
6805 anupam.sin 3969 
    Parameters:
3970 
     - itemId
6921 anupam.sin 3971 
     - price
6805 anupam.sin 3972 
     - insurerId
3973 
     - quantity
3974 
    """
6921 anupam.sin 3975 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3976 
    return self.recv_getInsuranceAmount()
3977 
 
6921 anupam.sin 3978 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3979 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3980 
    args = getInsuranceAmount_args()
3981 
    args.itemId = itemId
6921 anupam.sin 3982 
    args.price = price
6805 anupam.sin 3983 
    args.insurerId = insurerId
3984 
    args.quantity = quantity
3985 
    args.write(self._oprot)
3986 
    self._oprot.writeMessageEnd()
3987 
    self._oprot.trans.flush()
3988 
 
3989 
  def recv_getInsuranceAmount(self, ):
3990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3991 
    if mtype == TMessageType.EXCEPTION:
3992 
      x = TApplicationException()
3993 
      x.read(self._iprot)
3994 
      self._iprot.readMessageEnd()
3995 
      raise x
3996 
    result = getInsuranceAmount_result()
3997 
    result.read(self._iprot)
3998 
    self._iprot.readMessageEnd()
3999 
    if result.success is not None:
4000 
      return result.success
4001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
4002 
 
4003 
  def getInsurer(self, insurerId):
4004 
    """
4005 
    Parameters:
4006 
     - insurerId
4007 
    """
4008 
    self.send_getInsurer(insurerId)
4009 
    return self.recv_getInsurer()
4010 
 
4011 
  def send_getInsurer(self, insurerId):
4012 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
4013 
    args = getInsurer_args()
4014 
    args.insurerId = insurerId
4015 
    args.write(self._oprot)
4016 
    self._oprot.writeMessageEnd()
4017 
    self._oprot.trans.flush()
4018 
 
4019 
  def recv_getInsurer(self, ):
4020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4021 
    if mtype == TMessageType.EXCEPTION:
4022 
      x = TApplicationException()
4023 
      x.read(self._iprot)
4024 
      self._iprot.readMessageEnd()
4025 
      raise x
4026 
    result = getInsurer_result()
4027 
    result.read(self._iprot)
4028 
    self._iprot.readMessageEnd()
4029 
    if result.success is not None:
4030 
      return result.success
4031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
4032 
 
6838 vikram.rag 4033 
  def getAllInsurers(self, ):
4034 
    self.send_getAllInsurers()
4035 
    return self.recv_getAllInsurers()
6805 anupam.sin 4036 
 
6838 vikram.rag 4037 
  def send_getAllInsurers(self, ):
4038 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
4039 
    args = getAllInsurers_args()
4040 
    args.write(self._oprot)
4041 
    self._oprot.writeMessageEnd()
4042 
    self._oprot.trans.flush()
4043 
 
4044 
  def recv_getAllInsurers(self, ):
4045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4046 
    if mtype == TMessageType.EXCEPTION:
4047 
      x = TApplicationException()
4048 
      x.read(self._iprot)
4049 
      self._iprot.readMessageEnd()
4050 
      raise x
4051 
    result = getAllInsurers_result()
4052 
    result.read(self._iprot)
4053 
    self._iprot.readMessageEnd()
4054 
    if result.success is not None:
4055 
      return result.success
4056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
4057 
 
6962 rajveer 4058 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
4059 
    """
4060 
    Parameters:
4061 
     - insurerId
4062 
     - amount
4063 
    """
4064 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
4065 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 4066 
 
6962 rajveer 4067 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
4068 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
4069 
    args = updateInsuranceDeclaredAmount_args()
4070 
    args.insurerId = insurerId
4071 
    args.amount = amount
4072 
    args.write(self._oprot)
4073 
    self._oprot.writeMessageEnd()
4074 
    self._oprot.trans.flush()
4075 
 
4076 
  def recv_updateInsuranceDeclaredAmount(self, ):
4077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4078 
    if mtype == TMessageType.EXCEPTION:
4079 
      x = TApplicationException()
4080 
      x.read(self._iprot)
4081 
      self._iprot.readMessageEnd()
4082 
      raise x
4083 
    result = updateInsuranceDeclaredAmount_result()
4084 
    result.read(self._iprot)
4085 
    self._iprot.readMessageEnd()
4086 
    return
4087 
 
7190 amar.kumar 4088 
  def getFreebieForItem(self, itemId):
4089 
    """
4090 
    Parameters:
4091 
     - itemId
4092 
    """
4093 
    self.send_getFreebieForItem(itemId)
4094 
    return self.recv_getFreebieForItem()
6962 rajveer 4095 
 
7190 amar.kumar 4096 
  def send_getFreebieForItem(self, itemId):
4097 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
4098 
    args = getFreebieForItem_args()
4099 
    args.itemId = itemId
4100 
    args.write(self._oprot)
4101 
    self._oprot.writeMessageEnd()
4102 
    self._oprot.trans.flush()
4103 
 
4104 
  def recv_getFreebieForItem(self, ):
4105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4106 
    if mtype == TMessageType.EXCEPTION:
4107 
      x = TApplicationException()
4108 
      x.read(self._iprot)
4109 
      self._iprot.readMessageEnd()
4110 
      raise x
4111 
    result = getFreebieForItem_result()
4112 
    result.read(self._iprot)
4113 
    self._iprot.readMessageEnd()
4114 
    if result.success is not None:
4115 
      return result.success
4116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
4117 
 
4118 
  def addOrUpdateFreebieForItem(self, freebieItem):
4119 
    """
4120 
    Parameters:
4121 
     - freebieItem
4122 
    """
4123 
    self.send_addOrUpdateFreebieForItem(freebieItem)
4124 
    self.recv_addOrUpdateFreebieForItem()
4125 
 
4126 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
4127 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
4128 
    args = addOrUpdateFreebieForItem_args()
4129 
    args.freebieItem = freebieItem
4130 
    args.write(self._oprot)
4131 
    self._oprot.writeMessageEnd()
4132 
    self._oprot.trans.flush()
4133 
 
4134 
  def recv_addOrUpdateFreebieForItem(self, ):
4135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4136 
    if mtype == TMessageType.EXCEPTION:
4137 
      x = TApplicationException()
4138 
      x.read(self._iprot)
4139 
      self._iprot.readMessageEnd()
4140 
      raise x
4141 
    result = addOrUpdateFreebieForItem_result()
4142 
    result.read(self._iprot)
4143 
    self._iprot.readMessageEnd()
4144 
    return
4145 
 
7272 amit.gupta 4146 
  def addOrUpdateBrandInfo(self, brandInfo):
4147 
    """
4148 
    Parameters:
4149 
     - brandInfo
4150 
    """
4151 
    self.send_addOrUpdateBrandInfo(brandInfo)
4152 
    self.recv_addOrUpdateBrandInfo()
4153 
 
4154 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4155 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4156 
    args = addOrUpdateBrandInfo_args()
4157 
    args.brandInfo = brandInfo
4158 
    args.write(self._oprot)
4159 
    self._oprot.writeMessageEnd()
4160 
    self._oprot.trans.flush()
4161 
 
4162 
  def recv_addOrUpdateBrandInfo(self, ):
4163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4164 
    if mtype == TMessageType.EXCEPTION:
4165 
      x = TApplicationException()
4166 
      x.read(self._iprot)
4167 
      self._iprot.readMessageEnd()
4168 
      raise x
4169 
    result = addOrUpdateBrandInfo_result()
4170 
    result.read(self._iprot)
4171 
    self._iprot.readMessageEnd()
4172 
    return
4173 
 
4174 
  def getBrandInfo(self, ):
4175 
    self.send_getBrandInfo()
4176 
    return self.recv_getBrandInfo()
4177 
 
4178 
  def send_getBrandInfo(self, ):
4179 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4180 
    args = getBrandInfo_args()
4181 
    args.write(self._oprot)
4182 
    self._oprot.writeMessageEnd()
4183 
    self._oprot.trans.flush()
4184 
 
4185 
  def recv_getBrandInfo(self, ):
4186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4187 
    if mtype == TMessageType.EXCEPTION:
4188 
      x = TApplicationException()
4189 
      x.read(self._iprot)
4190 
      self._iprot.readMessageEnd()
4191 
      raise x
4192 
    result = getBrandInfo_result()
4193 
    result.read(self._iprot)
4194 
    self._iprot.readMessageEnd()
4195 
    if result.success is not None:
4196 
      return result.success
4197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4198 
 
7256 rajveer 4199 
  def getStorePricing(self, itemId):
4200 
    """
4201 
    Parameters:
4202 
     - itemId
4203 
    """
4204 
    self.send_getStorePricing(itemId)
4205 
    return self.recv_getStorePricing()
7190 amar.kumar 4206 
 
7256 rajveer 4207 
  def send_getStorePricing(self, itemId):
4208 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4209 
    args = getStorePricing_args()
4210 
    args.itemId = itemId
4211 
    args.write(self._oprot)
4212 
    self._oprot.writeMessageEnd()
4213 
    self._oprot.trans.flush()
4214 
 
4215 
  def recv_getStorePricing(self, ):
4216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4217 
    if mtype == TMessageType.EXCEPTION:
4218 
      x = TApplicationException()
4219 
      x.read(self._iprot)
4220 
      self._iprot.readMessageEnd()
4221 
      raise x
4222 
    result = getStorePricing_result()
4223 
    result.read(self._iprot)
4224 
    self._iprot.readMessageEnd()
4225 
    if result.success is not None:
4226 
      return result.success
4227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4228 
 
7306 rajveer 4229 
  def getStorePricings(self, itemIds):
4230 
    """
4231 
    Parameters:
4232 
     - itemIds
4233 
    """
4234 
    self.send_getStorePricings(itemIds)
4235 
    return self.recv_getStorePricings()
4236 
 
4237 
  def send_getStorePricings(self, itemIds):
4238 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4239 
    args = getStorePricings_args()
4240 
    args.itemIds = itemIds
4241 
    args.write(self._oprot)
4242 
    self._oprot.writeMessageEnd()
4243 
    self._oprot.trans.flush()
4244 
 
4245 
  def recv_getStorePricings(self, ):
4246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4247 
    if mtype == TMessageType.EXCEPTION:
4248 
      x = TApplicationException()
4249 
      x.read(self._iprot)
4250 
      self._iprot.readMessageEnd()
4251 
      raise x
4252 
    result = getStorePricings_result()
4253 
    result.read(self._iprot)
4254 
    self._iprot.readMessageEnd()
4255 
    if result.success is not None:
4256 
      return result.success
4257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4258 
 
7382 rajveer 4259 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4260 
    """
4261 
    Parameters:
4262 
     - sp
7382 rajveer 4263 
     - allColors
7265 rajveer 4264 
    """
7382 rajveer 4265 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4266 
    self.recv_updateStorePricing()
7256 rajveer 4267 
 
7382 rajveer 4268 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4269 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4270 
    args = updateStorePricing_args()
4271 
    args.sp = sp
7382 rajveer 4272 
    args.allColors = allColors
7265 rajveer 4273 
    args.write(self._oprot)
4274 
    self._oprot.writeMessageEnd()
4275 
    self._oprot.trans.flush()
4276 
 
4277 
  def recv_updateStorePricing(self, ):
4278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4279 
    if mtype == TMessageType.EXCEPTION:
4280 
      x = TApplicationException()
4281 
      x.read(self._iprot)
4282 
      self._iprot.readMessageEnd()
4283 
      raise x
4284 
    result = updateStorePricing_result()
4285 
    result.read(self._iprot)
4286 
    self._iprot.readMessageEnd()
4287 
    return
4288 
 
7281 kshitij.so 4289 
  def getAllAmazonListedItems(self, ):
4290 
    self.send_getAllAmazonListedItems()
4291 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4292 
 
7281 kshitij.so 4293 
  def send_getAllAmazonListedItems(self, ):
4294 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4295 
    args = getAllAmazonListedItems_args()
4296 
    args.write(self._oprot)
4297 
    self._oprot.writeMessageEnd()
4298 
    self._oprot.trans.flush()
4299 
 
4300 
  def recv_getAllAmazonListedItems(self, ):
4301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4302 
    if mtype == TMessageType.EXCEPTION:
4303 
      x = TApplicationException()
4304 
      x.read(self._iprot)
4305 
      self._iprot.readMessageEnd()
4306 
      raise x
4307 
    result = getAllAmazonListedItems_result()
4308 
    result.read(self._iprot)
4309 
    self._iprot.readMessageEnd()
4310 
    if result.success is not None:
4311 
      return result.success
4312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4313 
 
8619 kshitij.so 4314 
  def searchAmazonItems(self, searchTerm, offset, limit):
4315 
    """
4316 
    Parameters:
4317 
     - searchTerm
4318 
     - offset
4319 
     - limit
4320 
    """
4321 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4322 
    return self.recv_searchAmazonItems()
4323 
 
4324 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4325 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4326 
    args = searchAmazonItems_args()
4327 
    args.searchTerm = searchTerm
4328 
    args.offset = offset
4329 
    args.limit = limit
4330 
    args.write(self._oprot)
4331 
    self._oprot.writeMessageEnd()
4332 
    self._oprot.trans.flush()
4333 
 
4334 
  def recv_searchAmazonItems(self, ):
4335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4336 
    if mtype == TMessageType.EXCEPTION:
4337 
      x = TApplicationException()
4338 
      x.read(self._iprot)
4339 
      self._iprot.readMessageEnd()
4340 
      raise x
4341 
    result = searchAmazonItems_result()
4342 
    result.read(self._iprot)
4343 
    self._iprot.readMessageEnd()
4344 
    if result.success is not None:
4345 
      return result.success
4346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4347 
 
4348 
  def getAmazonSearchResultCount(self, searchTerm):
4349 
    """
4350 
    Parameters:
4351 
     - searchTerm
4352 
    """
4353 
    self.send_getAmazonSearchResultCount(searchTerm)
4354 
    return self.recv_getAmazonSearchResultCount()
4355 
 
4356 
  def send_getAmazonSearchResultCount(self, searchTerm):
4357 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4358 
    args = getAmazonSearchResultCount_args()
4359 
    args.searchTerm = searchTerm
4360 
    args.write(self._oprot)
4361 
    self._oprot.writeMessageEnd()
4362 
    self._oprot.trans.flush()
4363 
 
4364 
  def recv_getAmazonSearchResultCount(self, ):
4365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4366 
    if mtype == TMessageType.EXCEPTION:
4367 
      x = TApplicationException()
4368 
      x.read(self._iprot)
4369 
      self._iprot.readMessageEnd()
4370 
      raise x
4371 
    result = getAmazonSearchResultCount_result()
4372 
    result.read(self._iprot)
4373 
    self._iprot.readMessageEnd()
4374 
    if result.success is not None:
4375 
      return result.success
4376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4377 
 
4378 
  def getCountForAmazonlistedItems(self, ):
4379 
    self.send_getCountForAmazonlistedItems()
4380 
    return self.recv_getCountForAmazonlistedItems()
4381 
 
4382 
  def send_getCountForAmazonlistedItems(self, ):
4383 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4384 
    args = getCountForAmazonlistedItems_args()
4385 
    args.write(self._oprot)
4386 
    self._oprot.writeMessageEnd()
4387 
    self._oprot.trans.flush()
4388 
 
4389 
  def recv_getCountForAmazonlistedItems(self, ):
4390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4391 
    if mtype == TMessageType.EXCEPTION:
4392 
      x = TApplicationException()
4393 
      x.read(self._iprot)
4394 
      self._iprot.readMessageEnd()
4395 
      raise x
4396 
    result = getCountForAmazonlistedItems_result()
4397 
    result.read(self._iprot)
4398 
    self._iprot.readMessageEnd()
4399 
    if result.success is not None:
4400 
      return result.success
4401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4402 
 
7281 kshitij.so 4403 
  def getAmazonItemDetails(self, itemId):
4404 
    """
4405 
    Parameters:
4406 
     - itemId
4407 
    """
4408 
    self.send_getAmazonItemDetails(itemId)
4409 
    return self.recv_getAmazonItemDetails()
4410 
 
4411 
  def send_getAmazonItemDetails(self, itemId):
4412 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4413 
    args = getAmazonItemDetails_args()
4414 
    args.itemId = itemId
4415 
    args.write(self._oprot)
4416 
    self._oprot.writeMessageEnd()
4417 
    self._oprot.trans.flush()
4418 
 
4419 
  def recv_getAmazonItemDetails(self, ):
4420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4421 
    if mtype == TMessageType.EXCEPTION:
4422 
      x = TApplicationException()
4423 
      x.read(self._iprot)
4424 
      self._iprot.readMessageEnd()
4425 
      raise x
4426 
    result = getAmazonItemDetails_result()
4427 
    result.read(self._iprot)
4428 
    self._iprot.readMessageEnd()
4429 
    if result.success is not None:
4430 
      return result.success
4431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4432 
 
8168 kshitij.so 4433 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4434 
    """
4435 
    Parameters:
8168 kshitij.so 4436 
     - amazonlisted
7281 kshitij.so 4437 
    """
8168 kshitij.so 4438 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4439 
    self.recv_updateAmazonItemDetails()
4440 
 
8168 kshitij.so 4441 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4442 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4443 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4444 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4445 
    args.write(self._oprot)
4446 
    self._oprot.writeMessageEnd()
4447 
    self._oprot.trans.flush()
4448 
 
4449 
  def recv_updateAmazonItemDetails(self, ):
4450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4451 
    if mtype == TMessageType.EXCEPTION:
4452 
      x = TApplicationException()
4453 
      x.read(self._iprot)
4454 
      self._iprot.readMessageEnd()
4455 
      raise x
4456 
    result = updateAmazonItemDetails_result()
4457 
    result.read(self._iprot)
4458 
    self._iprot.readMessageEnd()
4459 
    return
4460 
 
4461 
  def addAmazonItem(self, amazonlisted):
4462 
    """
4463 
    Parameters:
4464 
     - amazonlisted
4465 
    """
4466 
    self.send_addAmazonItem(amazonlisted)
4467 
    self.recv_addAmazonItem()
4468 
 
4469 
  def send_addAmazonItem(self, amazonlisted):
4470 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4471 
    args = addAmazonItem_args()
4472 
    args.amazonlisted = amazonlisted
4473 
    args.write(self._oprot)
4474 
    self._oprot.writeMessageEnd()
4475 
    self._oprot.trans.flush()
4476 
 
4477 
  def recv_addAmazonItem(self, ):
4478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4479 
    if mtype == TMessageType.EXCEPTION:
4480 
      x = TApplicationException()
4481 
      x.read(self._iprot)
4482 
      self._iprot.readMessageEnd()
4483 
      raise x
4484 
    result = addAmazonItem_result()
4485 
    result.read(self._iprot)
4486 
    self._iprot.readMessageEnd()
4487 
    return
4488 
 
7291 vikram.rag 4489 
  def getAsinItems(self, ):
4490 
    self.send_getAsinItems()
4491 
    return self.recv_getAsinItems()
7281 kshitij.so 4492 
 
7291 vikram.rag 4493 
  def send_getAsinItems(self, ):
4494 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4495 
    args = getAsinItems_args()
4496 
    args.write(self._oprot)
4497 
    self._oprot.writeMessageEnd()
4498 
    self._oprot.trans.flush()
4499 
 
4500 
  def recv_getAsinItems(self, ):
4501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4502 
    if mtype == TMessageType.EXCEPTION:
4503 
      x = TApplicationException()
4504 
      x.read(self._iprot)
4505 
      self._iprot.readMessageEnd()
4506 
      raise x
4507 
    result = getAsinItems_result()
4508 
    result.read(self._iprot)
4509 
    self._iprot.readMessageEnd()
4510 
    if result.success is not None:
4511 
      return result.success
4512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4513 
 
4514 
  def getAllFbaListedItems(self, ):
4515 
    self.send_getAllFbaListedItems()
4516 
    return self.recv_getAllFbaListedItems()
4517 
 
4518 
  def send_getAllFbaListedItems(self, ):
4519 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4520 
    args = getAllFbaListedItems_args()
4521 
    args.write(self._oprot)
4522 
    self._oprot.writeMessageEnd()
4523 
    self._oprot.trans.flush()
4524 
 
4525 
  def recv_getAllFbaListedItems(self, ):
4526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4527 
    if mtype == TMessageType.EXCEPTION:
4528 
      x = TApplicationException()
4529 
      x.read(self._iprot)
4530 
      self._iprot.readMessageEnd()
4531 
      raise x
4532 
    result = getAllFbaListedItems_result()
4533 
    result.read(self._iprot)
4534 
    self._iprot.readMessageEnd()
4535 
    if result.success is not None:
4536 
      return result.success
4537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4538 
 
4539 
  def getAllNonFbaListedItems(self, ):
4540 
    self.send_getAllNonFbaListedItems()
4541 
    return self.recv_getAllNonFbaListedItems()
4542 
 
4543 
  def send_getAllNonFbaListedItems(self, ):
4544 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4545 
    args = getAllNonFbaListedItems_args()
4546 
    args.write(self._oprot)
4547 
    self._oprot.writeMessageEnd()
4548 
    self._oprot.trans.flush()
4549 
 
4550 
  def recv_getAllNonFbaListedItems(self, ):
4551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4552 
    if mtype == TMessageType.EXCEPTION:
4553 
      x = TApplicationException()
4554 
      x.read(self._iprot)
4555 
      self._iprot.readMessageEnd()
4556 
      raise x
4557 
    result = getAllNonFbaListedItems_result()
4558 
    result.read(self._iprot)
4559 
    self._iprot.readMessageEnd()
4560 
    if result.success is not None:
4561 
      return result.success
4562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4563 
 
7460 kshitij.so 4564 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4565 
    """
4566 
    Parameters:
4567 
     - itemId
4568 
     - holdInventory
4569 
     - defaultInventory
4570 
    """
4571 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4572 
    return self.recv_updateItemInventory()
7291 vikram.rag 4573 
 
7460 kshitij.so 4574 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4575 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4576 
    args = updateItemInventory_args()
4577 
    args.itemId = itemId
4578 
    args.holdInventory = holdInventory
4579 
    args.defaultInventory = defaultInventory
4580 
    args.write(self._oprot)
4581 
    self._oprot.writeMessageEnd()
4582 
    self._oprot.trans.flush()
4583 
 
4584 
  def recv_updateItemInventory(self, ):
4585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4586 
    if mtype == TMessageType.EXCEPTION:
4587 
      x = TApplicationException()
4588 
      x.read(self._iprot)
4589 
      self._iprot.readMessageEnd()
4590 
      raise x
4591 
    result = updateItemInventory_result()
4592 
    result.read(self._iprot)
4593 
    self._iprot.readMessageEnd()
4594 
    if result.success is not None:
4595 
      return result.success
4596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4597 
 
7770 kshitij.so 4598 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4599 
    """
4600 
    Parameters:
4601 
     - type
4602 
     - sku
4603 
     - timestamp
4604 
    """
4605 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4606 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4607 
 
7770 kshitij.so 4608 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4609 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4610 
    args = updateTimestampForAmazonFeeds_args()
4611 
    args.type = type
4612 
    args.sku = sku
4613 
    args.timestamp = timestamp
4614 
    args.write(self._oprot)
4615 
    self._oprot.writeMessageEnd()
4616 
    self._oprot.trans.flush()
4617 
 
4618 
  def recv_updateTimestampForAmazonFeeds(self, ):
4619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4620 
    if mtype == TMessageType.EXCEPTION:
4621 
      x = TApplicationException()
4622 
      x.read(self._iprot)
4623 
      self._iprot.readMessageEnd()
4624 
      raise x
4625 
    result = updateTimestampForAmazonFeeds_result()
4626 
    result.read(self._iprot)
4627 
    self._iprot.readMessageEnd()
4628 
    if result.success is not None:
4629 
      return result.success
4630 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4631 
 
7897 amar.kumar 4632 
  def getAllParentCategories(self, ):
4633 
    self.send_getAllParentCategories()
4634 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4635 
 
7897 amar.kumar 4636 
  def send_getAllParentCategories(self, ):
4637 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4638 
    args = getAllParentCategories_args()
4639 
    args.write(self._oprot)
4640 
    self._oprot.writeMessageEnd()
4641 
    self._oprot.trans.flush()
4642 
 
4643 
  def recv_getAllParentCategories(self, ):
4644 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4645 
    if mtype == TMessageType.EXCEPTION:
4646 
      x = TApplicationException()
4647 
      x.read(self._iprot)
4648 
      self._iprot.readMessageEnd()
4649 
      raise x
4650 
    result = getAllParentCategories_result()
4651 
    result.read(self._iprot)
4652 
    self._iprot.readMessageEnd()
4653 
    if result.success is not None:
4654 
      return result.success
4655 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4656 
 
7977 kshitij.so 4657 
  def addPageViewEvent(self, pageViewEvents):
4658 
    """
4659 
    Parameters:
4660 
     - pageViewEvents
4661 
    """
4662 
    self.send_addPageViewEvent(pageViewEvents)
4663 
    self.recv_addPageViewEvent()
7897 amar.kumar 4664 
 
7977 kshitij.so 4665 
  def send_addPageViewEvent(self, pageViewEvents):
4666 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4667 
    args = addPageViewEvent_args()
4668 
    args.pageViewEvents = pageViewEvents
4669 
    args.write(self._oprot)
4670 
    self._oprot.writeMessageEnd()
4671 
    self._oprot.trans.flush()
4672 
 
4673 
  def recv_addPageViewEvent(self, ):
4674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4675 
    if mtype == TMessageType.EXCEPTION:
4676 
      x = TApplicationException()
4677 
      x.read(self._iprot)
4678 
      self._iprot.readMessageEnd()
4679 
      raise x
4680 
    result = addPageViewEvent_result()
4681 
    result.read(self._iprot)
4682 
    self._iprot.readMessageEnd()
4683 
    return
4684 
 
4685 
  def addCartEvent(self, cartEvents):
4686 
    """
4687 
    Parameters:
4688 
     - cartEvents
4689 
    """
4690 
    self.send_addCartEvent(cartEvents)
4691 
    self.recv_addCartEvent()
4692 
 
4693 
  def send_addCartEvent(self, cartEvents):
4694 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4695 
    args = addCartEvent_args()
4696 
    args.cartEvents = cartEvents
4697 
    args.write(self._oprot)
4698 
    self._oprot.writeMessageEnd()
4699 
    self._oprot.trans.flush()
4700 
 
4701 
  def recv_addCartEvent(self, ):
4702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4703 
    if mtype == TMessageType.EXCEPTION:
4704 
      x = TApplicationException()
4705 
      x.read(self._iprot)
4706 
      self._iprot.readMessageEnd()
4707 
      raise x
4708 
    result = addCartEvent_result()
4709 
    result.read(self._iprot)
4710 
    self._iprot.readMessageEnd()
4711 
    return
4712 
 
8182 amar.kumar 4713 
  def addEbayItem(self, ebayItem):
4714 
    """
4715 
    Parameters:
4716 
     - ebayItem
4717 
    """
4718 
    self.send_addEbayItem(ebayItem)
4719 
    self.recv_addEbayItem()
4720 
 
4721 
  def send_addEbayItem(self, ebayItem):
4722 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4723 
    args = addEbayItem_args()
4724 
    args.ebayItem = ebayItem
4725 
    args.write(self._oprot)
4726 
    self._oprot.writeMessageEnd()
4727 
    self._oprot.trans.flush()
4728 
 
4729 
  def recv_addEbayItem(self, ):
4730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4731 
    if mtype == TMessageType.EXCEPTION:
4732 
      x = TApplicationException()
4733 
      x.read(self._iprot)
4734 
      self._iprot.readMessageEnd()
4735 
      raise x
4736 
    result = addEbayItem_result()
4737 
    result.read(self._iprot)
4738 
    self._iprot.readMessageEnd()
4739 
    return
4740 
 
4741 
  def getEbayItem(self, listingId):
4742 
    """
4743 
    Parameters:
4744 
     - listingId
4745 
    """
4746 
    self.send_getEbayItem(listingId)
4747 
    return self.recv_getEbayItem()
4748 
 
4749 
  def send_getEbayItem(self, listingId):
4750 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4751 
    args = getEbayItem_args()
4752 
    args.listingId = listingId
4753 
    args.write(self._oprot)
4754 
    self._oprot.writeMessageEnd()
4755 
    self._oprot.trans.flush()
4756 
 
4757 
  def recv_getEbayItem(self, ):
4758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4759 
    if mtype == TMessageType.EXCEPTION:
4760 
      x = TApplicationException()
4761 
      x.read(self._iprot)
4762 
      self._iprot.readMessageEnd()
4763 
      raise x
4764 
    result = getEbayItem_result()
4765 
    result.read(self._iprot)
4766 
    self._iprot.readMessageEnd()
4767 
    if result.success is not None:
4768 
      return result.success
4769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4770 
 
4771 
  def updateEbayItem(self, ebayItem):
4772 
    """
4773 
    Parameters:
4774 
     - ebayItem
4775 
    """
4776 
    self.send_updateEbayItem(ebayItem)
4777 
    self.recv_updateEbayItem()
4778 
 
4779 
  def send_updateEbayItem(self, ebayItem):
4780 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4781 
    args = updateEbayItem_args()
4782 
    args.ebayItem = ebayItem
4783 
    args.write(self._oprot)
4784 
    self._oprot.writeMessageEnd()
4785 
    self._oprot.trans.flush()
4786 
 
4787 
  def recv_updateEbayItem(self, ):
4788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4789 
    if mtype == TMessageType.EXCEPTION:
4790 
      x = TApplicationException()
4791 
      x.read(self._iprot)
4792 
      self._iprot.readMessageEnd()
4793 
      raise x
4794 
    result = updateEbayItem_result()
4795 
    result.read(self._iprot)
4796 
    self._iprot.readMessageEnd()
4797 
    return
4798 
 
8139 kshitij.so 4799 
  def getAmazonListedItems(self, offset, limit):
4800 
    """
4801 
    Parameters:
4802 
     - offset
4803 
     - limit
4804 
    """
4805 
    self.send_getAmazonListedItems(offset, limit)
4806 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4807 
 
8139 kshitij.so 4808 
  def send_getAmazonListedItems(self, offset, limit):
4809 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4810 
    args = getAmazonListedItems_args()
4811 
    args.offset = offset
4812 
    args.limit = limit
4813 
    args.write(self._oprot)
4814 
    self._oprot.writeMessageEnd()
4815 
    self._oprot.trans.flush()
4816 
 
4817 
  def recv_getAmazonListedItems(self, ):
4818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4819 
    if mtype == TMessageType.EXCEPTION:
4820 
      x = TApplicationException()
4821 
      x.read(self._iprot)
4822 
      self._iprot.readMessageEnd()
4823 
      raise x
4824 
    result = getAmazonListedItems_result()
4825 
    result.read(self._iprot)
4826 
    self._iprot.readMessageEnd()
4827 
    if result.success is not None:
4828 
      return result.success
4829 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4830 
 
8168 kshitij.so 4831 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4832 
    """
4833 
    Parameters:
4834 
     - amazonlisted
4835 
    """
4836 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4837 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4838 
 
8168 kshitij.so 4839 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4840 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4841 
    args = updateAmazonAttributesInBulk_args()
4842 
    args.amazonlisted = amazonlisted
4843 
    args.write(self._oprot)
4844 
    self._oprot.writeMessageEnd()
4845 
    self._oprot.trans.flush()
4846 
 
4847 
  def recv_updateAmazonAttributesInBulk(self, ):
4848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4849 
    if mtype == TMessageType.EXCEPTION:
4850 
      x = TApplicationException()
4851 
      x.read(self._iprot)
4852 
      self._iprot.readMessageEnd()
4853 
      raise x
4854 
    result = updateAmazonAttributesInBulk_result()
4855 
    result.read(self._iprot)
4856 
    self._iprot.readMessageEnd()
4857 
    if result.success is not None:
4858 
      return result.success
4859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4860 
 
8379 vikram.rag 4861 
  def getAllItemstoListOnFba(self, ):
4862 
    self.send_getAllItemstoListOnFba()
4863 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4864 
 
8379 vikram.rag 4865 
  def send_getAllItemstoListOnFba(self, ):
4866 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4867 
    args = getAllItemstoListOnFba_args()
4868 
    args.write(self._oprot)
4869 
    self._oprot.writeMessageEnd()
4870 
    self._oprot.trans.flush()
4871 
 
4872 
  def recv_getAllItemstoListOnFba(self, ):
4873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4874 
    if mtype == TMessageType.EXCEPTION:
4875 
      x = TApplicationException()
4876 
      x.read(self._iprot)
4877 
      self._iprot.readMessageEnd()
4878 
      raise x
4879 
    result = getAllItemstoListOnFba_result()
4880 
    result.read(self._iprot)
4881 
    self._iprot.readMessageEnd()
4882 
    if result.success is not None:
4883 
      return result.success
4884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4885 
 
4886 
  def getAllItemstoListOnNonFba(self, ):
4887 
    self.send_getAllItemstoListOnNonFba()
4888 
    return self.recv_getAllItemstoListOnNonFba()
4889 
 
4890 
  def send_getAllItemstoListOnNonFba(self, ):
4891 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4892 
    args = getAllItemstoListOnNonFba_args()
4893 
    args.write(self._oprot)
4894 
    self._oprot.writeMessageEnd()
4895 
    self._oprot.trans.flush()
4896 
 
4897 
  def recv_getAllItemstoListOnNonFba(self, ):
4898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4899 
    if mtype == TMessageType.EXCEPTION:
4900 
      x = TApplicationException()
4901 
      x.read(self._iprot)
4902 
      self._iprot.readMessageEnd()
4903 
      raise x
4904 
    result = getAllItemstoListOnNonFba_result()
4905 
    result.read(self._iprot)
4906 
    self._iprot.readMessageEnd()
4907 
    if result.success is not None:
4908 
      return result.success
4909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4910 
 
8619 kshitij.so 4911 
  def updateAsin(self, item):
4912 
    """
4913 
    Parameters:
4914 
     - item
4915 
    """
4916 
    self.send_updateAsin(item)
4917 
    self.recv_updateAsin()
8616 vikram.rag 4918 
 
8619 kshitij.so 4919 
  def send_updateAsin(self, item):
4920 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4921 
    args = updateAsin_args()
4922 
    args.item = item
4923 
    args.write(self._oprot)
4924 
    self._oprot.writeMessageEnd()
4925 
    self._oprot.trans.flush()
4926 
 
4927 
  def recv_updateAsin(self, ):
4928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4929 
    if mtype == TMessageType.EXCEPTION:
4930 
      x = TApplicationException()
4931 
      x.read(self._iprot)
4932 
      self._iprot.readMessageEnd()
4933 
      raise x
4934 
    result = updateAsin_result()
4935 
    result.read(self._iprot)
4936 
    self._iprot.readMessageEnd()
4937 
    return
4938 
 
8739 vikram.rag 4939 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4940 
    """
4941 
    Parameters:
4942 
     - snapdealitem
4943 
    """
4944 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4945 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4946 
 
8739 vikram.rag 4947 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4948 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4949 
    args = addOrUpdateSnapdealItem_args()
4950 
    args.snapdealitem = snapdealitem
4951 
    args.write(self._oprot)
4952 
    self._oprot.writeMessageEnd()
4953 
    self._oprot.trans.flush()
4954 
 
4955 
  def recv_addOrUpdateSnapdealItem(self, ):
4956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4957 
    if mtype == TMessageType.EXCEPTION:
4958 
      x = TApplicationException()
4959 
      x.read(self._iprot)
4960 
      self._iprot.readMessageEnd()
4961 
      raise x
4962 
    result = addOrUpdateSnapdealItem_result()
4963 
    result.read(self._iprot)
4964 
    self._iprot.readMessageEnd()
4965 
    if result.success is not None:
4966 
      return result.success
4967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4968 
 
4969 
  def getSnapdealItem(self, item_id):
4970 
    """
4971 
    Parameters:
4972 
     - item_id
4973 
    """
4974 
    self.send_getSnapdealItem(item_id)
4975 
    return self.recv_getSnapdealItem()
4976 
 
4977 
  def send_getSnapdealItem(self, item_id):
4978 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4979 
    args = getSnapdealItem_args()
4980 
    args.item_id = item_id
4981 
    args.write(self._oprot)
4982 
    self._oprot.writeMessageEnd()
4983 
    self._oprot.trans.flush()
4984 
 
4985 
  def recv_getSnapdealItem(self, ):
4986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4987 
    if mtype == TMessageType.EXCEPTION:
4988 
      x = TApplicationException()
4989 
      x.read(self._iprot)
4990 
      self._iprot.readMessageEnd()
4991 
      raise x
4992 
    result = getSnapdealItem_result()
4993 
    result.read(self._iprot)
4994 
    self._iprot.readMessageEnd()
4995 
    if result.success is not None:
4996 
      return result.success
4997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4998 
 
9242 kshitij.so 4999 
  def getSnapdealItemDetails(self, item_id):
5000 
    """
5001 
    Parameters:
5002 
     - item_id
5003 
    """
5004 
    self.send_getSnapdealItemDetails(item_id)
5005 
    return self.recv_getSnapdealItemDetails()
5006 
 
5007 
  def send_getSnapdealItemDetails(self, item_id):
5008 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
5009 
    args = getSnapdealItemDetails_args()
5010 
    args.item_id = item_id
5011 
    args.write(self._oprot)
5012 
    self._oprot.writeMessageEnd()
5013 
    self._oprot.trans.flush()
5014 
 
5015 
  def recv_getSnapdealItemDetails(self, ):
5016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5017 
    if mtype == TMessageType.EXCEPTION:
5018 
      x = TApplicationException()
5019 
      x.read(self._iprot)
5020 
      self._iprot.readMessageEnd()
5021 
      raise x
5022 
    result = getSnapdealItemDetails_result()
5023 
    result.read(self._iprot)
5024 
    self._iprot.readMessageEnd()
5025 
    if result.success is not None:
5026 
      return result.success
5027 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
5028 
 
8739 vikram.rag 5029 
  def getAllSnapdealItems(self, ):
5030 
    self.send_getAllSnapdealItems()
5031 
    return self.recv_getAllSnapdealItems()
5032 
 
5033 
  def send_getAllSnapdealItems(self, ):
5034 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
5035 
    args = getAllSnapdealItems_args()
5036 
    args.write(self._oprot)
5037 
    self._oprot.writeMessageEnd()
5038 
    self._oprot.trans.flush()
5039 
 
5040 
  def recv_getAllSnapdealItems(self, ):
5041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5042 
    if mtype == TMessageType.EXCEPTION:
5043 
      x = TApplicationException()
5044 
      x.read(self._iprot)
5045 
      self._iprot.readMessageEnd()
5046 
      raise x
5047 
    result = getAllSnapdealItems_result()
5048 
    result.read(self._iprot)
5049 
    self._iprot.readMessageEnd()
5050 
    if result.success is not None:
5051 
      return result.success
5052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
5053 
 
9242 kshitij.so 5054 
  def getSnapdealItems(self, offset, limit):
5055 
    """
5056 
    Parameters:
5057 
     - offset
5058 
     - limit
5059 
    """
5060 
    self.send_getSnapdealItems(offset, limit)
5061 
    return self.recv_getSnapdealItems()
8739 vikram.rag 5062 
 
9242 kshitij.so 5063 
  def send_getSnapdealItems(self, offset, limit):
5064 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
5065 
    args = getSnapdealItems_args()
5066 
    args.offset = offset
5067 
    args.limit = limit
5068 
    args.write(self._oprot)
5069 
    self._oprot.writeMessageEnd()
5070 
    self._oprot.trans.flush()
5071 
 
5072 
  def recv_getSnapdealItems(self, ):
5073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5074 
    if mtype == TMessageType.EXCEPTION:
5075 
      x = TApplicationException()
5076 
      x.read(self._iprot)
5077 
      self._iprot.readMessageEnd()
5078 
      raise x
5079 
    result = getSnapdealItems_result()
5080 
    result.read(self._iprot)
5081 
    self._iprot.readMessageEnd()
5082 
    if result.success is not None:
5083 
      return result.success
5084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
5085 
 
5086 
  def searchSnapdealItems(self, searchTerm, offset, limit):
5087 
    """
5088 
    Parameters:
5089 
     - searchTerm
5090 
     - offset
5091 
     - limit
5092 
    """
5093 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
5094 
    return self.recv_searchSnapdealItems()
5095 
 
5096 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
5097 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
5098 
    args = searchSnapdealItems_args()
5099 
    args.searchTerm = searchTerm
5100 
    args.offset = offset
5101 
    args.limit = limit
5102 
    args.write(self._oprot)
5103 
    self._oprot.writeMessageEnd()
5104 
    self._oprot.trans.flush()
5105 
 
5106 
  def recv_searchSnapdealItems(self, ):
5107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5108 
    if mtype == TMessageType.EXCEPTION:
5109 
      x = TApplicationException()
5110 
      x.read(self._iprot)
5111 
      self._iprot.readMessageEnd()
5112 
      raise x
5113 
    result = searchSnapdealItems_result()
5114 
    result.read(self._iprot)
5115 
    self._iprot.readMessageEnd()
5116 
    if result.success is not None:
5117 
      return result.success
5118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
5119 
 
5120 
  def getCountForSnapdealItems(self, ):
5121 
    self.send_getCountForSnapdealItems()
5122 
    return self.recv_getCountForSnapdealItems()
5123 
 
5124 
  def send_getCountForSnapdealItems(self, ):
5125 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
5126 
    args = getCountForSnapdealItems_args()
5127 
    args.write(self._oprot)
5128 
    self._oprot.writeMessageEnd()
5129 
    self._oprot.trans.flush()
5130 
 
5131 
  def recv_getCountForSnapdealItems(self, ):
5132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5133 
    if mtype == TMessageType.EXCEPTION:
5134 
      x = TApplicationException()
5135 
      x.read(self._iprot)
5136 
      self._iprot.readMessageEnd()
5137 
      raise x
5138 
    result = getCountForSnapdealItems_result()
5139 
    result.read(self._iprot)
5140 
    self._iprot.readMessageEnd()
5141 
    if result.success is not None:
5142 
      return result.success
5143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5144 
 
5145 
  def getSnapdealSearchResultCount(self, searchTerm):
5146 
    """
5147 
    Parameters:
5148 
     - searchTerm
5149 
    """
5150 
    self.send_getSnapdealSearchResultCount(searchTerm)
5151 
    return self.recv_getSnapdealSearchResultCount()
5152 
 
5153 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5154 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5155 
    args = getSnapdealSearchResultCount_args()
5156 
    args.searchTerm = searchTerm
5157 
    args.write(self._oprot)
5158 
    self._oprot.writeMessageEnd()
5159 
    self._oprot.trans.flush()
5160 
 
5161 
  def recv_getSnapdealSearchResultCount(self, ):
5162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5163 
    if mtype == TMessageType.EXCEPTION:
5164 
      x = TApplicationException()
5165 
      x.read(self._iprot)
5166 
      self._iprot.readMessageEnd()
5167 
      raise x
5168 
    result = getSnapdealSearchResultCount_result()
5169 
    result.read(self._iprot)
5170 
    self._iprot.readMessageEnd()
5171 
    if result.success is not None:
5172 
      return result.success
5173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5174 
 
9299 kshitij.so 5175 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5176 
    """
5177 
    Parameters:
5178 
     - itemId
5179 
     - insurerType
5180 
    """
5181 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5182 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5183 
 
9299 kshitij.so 5184 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5185 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5186 
    args = getPrefferedInsurerForItem_args()
5187 
    args.itemId = itemId
5188 
    args.insurerType = insurerType
5189 
    args.write(self._oprot)
5190 
    self._oprot.writeMessageEnd()
5191 
    self._oprot.trans.flush()
5192 
 
5193 
  def recv_getPrefferedInsurerForItem(self, ):
5194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5195 
    if mtype == TMessageType.EXCEPTION:
5196 
      x = TApplicationException()
5197 
      x.read(self._iprot)
5198 
      self._iprot.readMessageEnd()
5199 
      raise x
5200 
    result = getPrefferedInsurerForItem_result()
5201 
    result.read(self._iprot)
5202 
    self._iprot.readMessageEnd()
5203 
    if result.success is not None:
5204 
      return result.success
5205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5206 
 
9456 vikram.rag 5207 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5208 
    """
5209 
    Parameters:
5210 
     - skuAtSnapdeal
5211 
    """
5212 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5213 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5214 
 
9456 vikram.rag 5215 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5216 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5217 
    args = getSnapdealItembySkuAtSnapdeal_args()
5218 
    args.skuAtSnapdeal = skuAtSnapdeal
5219 
    args.write(self._oprot)
5220 
    self._oprot.writeMessageEnd()
5221 
    self._oprot.trans.flush()
5222 
 
5223 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5225 
    if mtype == TMessageType.EXCEPTION:
5226 
      x = TApplicationException()
5227 
      x.read(self._iprot)
5228 
      self._iprot.readMessageEnd()
5229 
      raise x
5230 
    result = getSnapdealItembySkuAtSnapdeal_result()
5231 
    result.read(self._iprot)
5232 
    self._iprot.readMessageEnd()
5233 
    if result.success is not None:
5234 
      return result.success
5235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5236 
 
9621 manish.sha 5237 
  def getProductFeedSubmit(self, catalogItemId):
5238 
    """
5239 
    Parameters:
5240 
     - catalogItemId
5241 
    """
5242 
    self.send_getProductFeedSubmit(catalogItemId)
5243 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5244 
 
9621 manish.sha 5245 
  def send_getProductFeedSubmit(self, catalogItemId):
5246 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5247 
    args = getProductFeedSubmit_args()
5248 
    args.catalogItemId = catalogItemId
5249 
    args.write(self._oprot)
5250 
    self._oprot.writeMessageEnd()
5251 
    self._oprot.trans.flush()
5252 
 
5253 
  def recv_getProductFeedSubmit(self, ):
5254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5255 
    if mtype == TMessageType.EXCEPTION:
5256 
      x = TApplicationException()
5257 
      x.read(self._iprot)
5258 
      self._iprot.readMessageEnd()
5259 
      raise x
5260 
    result = getProductFeedSubmit_result()
5261 
    result.read(self._iprot)
5262 
    self._iprot.readMessageEnd()
5263 
    if result.success is not None:
5264 
      return result.success
5265 
    if result.cex is not None:
5266 
      raise result.cex
5267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5268 
 
5269 
  def addProductFeedSubmit(self, productFeedSubmit):
5270 
    """
5271 
    Parameters:
5272 
     - productFeedSubmit
5273 
    """
5274 
    self.send_addProductFeedSubmit(productFeedSubmit)
5275 
    return self.recv_addProductFeedSubmit()
5276 
 
5277 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5278 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5279 
    args = addProductFeedSubmit_args()
5280 
    args.productFeedSubmit = productFeedSubmit
5281 
    args.write(self._oprot)
5282 
    self._oprot.writeMessageEnd()
5283 
    self._oprot.trans.flush()
5284 
 
5285 
  def recv_addProductFeedSubmit(self, ):
5286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5287 
    if mtype == TMessageType.EXCEPTION:
5288 
      x = TApplicationException()
5289 
      x.read(self._iprot)
5290 
      self._iprot.readMessageEnd()
5291 
      raise x
5292 
    result = addProductFeedSubmit_result()
5293 
    result.read(self._iprot)
5294 
    self._iprot.readMessageEnd()
5295 
    if result.success is not None:
5296 
      return result.success
5297 
    if result.cex is not None:
5298 
      raise result.cex
5299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5300 
 
5301 
  def updateProductFeedSubmit(self, productFeedSubmit):
5302 
    """
5303 
    Parameters:
5304 
     - productFeedSubmit
5305 
    """
5306 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5307 
    return self.recv_updateProductFeedSubmit()
5308 
 
5309 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5310 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5311 
    args = updateProductFeedSubmit_args()
5312 
    args.productFeedSubmit = productFeedSubmit
5313 
    args.write(self._oprot)
5314 
    self._oprot.writeMessageEnd()
5315 
    self._oprot.trans.flush()
5316 
 
5317 
  def recv_updateProductFeedSubmit(self, ):
5318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5319 
    if mtype == TMessageType.EXCEPTION:
5320 
      x = TApplicationException()
5321 
      x.read(self._iprot)
5322 
      self._iprot.readMessageEnd()
5323 
      raise x
5324 
    result = updateProductFeedSubmit_result()
5325 
    result.read(self._iprot)
5326 
    self._iprot.readMessageEnd()
5327 
    if result.success is not None:
5328 
      return result.success
5329 
    if result.cex is not None:
5330 
      raise result.cex
5331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5332 
 
5333 
  def deleteProductFeedSubmit(self, catalogItemId):
5334 
    """
5335 
    Parameters:
5336 
     - catalogItemId
5337 
    """
5338 
    self.send_deleteProductFeedSubmit(catalogItemId)
5339 
    return self.recv_deleteProductFeedSubmit()
5340 
 
5341 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5342 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5343 
    args = deleteProductFeedSubmit_args()
5344 
    args.catalogItemId = catalogItemId
5345 
    args.write(self._oprot)
5346 
    self._oprot.writeMessageEnd()
5347 
    self._oprot.trans.flush()
5348 
 
5349 
  def recv_deleteProductFeedSubmit(self, ):
5350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5351 
    if mtype == TMessageType.EXCEPTION:
5352 
      x = TApplicationException()
5353 
      x.read(self._iprot)
5354 
      self._iprot.readMessageEnd()
5355 
      raise x
5356 
    result = deleteProductFeedSubmit_result()
5357 
    result.read(self._iprot)
5358 
    self._iprot.readMessageEnd()
5359 
    if result.success is not None:
5360 
      return result.success
5361 
    if result.cex is not None:
5362 
      raise result.cex
5363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5364 
 
5365 
  def getAllProductFeedSubmit(self, ):
5366 
    self.send_getAllProductFeedSubmit()
5367 
    return self.recv_getAllProductFeedSubmit()
5368 
 
5369 
  def send_getAllProductFeedSubmit(self, ):
5370 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5371 
    args = getAllProductFeedSubmit_args()
5372 
    args.write(self._oprot)
5373 
    self._oprot.writeMessageEnd()
5374 
    self._oprot.trans.flush()
5375 
 
5376 
  def recv_getAllProductFeedSubmit(self, ):
5377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5378 
    if mtype == TMessageType.EXCEPTION:
5379 
      x = TApplicationException()
5380 
      x.read(self._iprot)
5381 
      self._iprot.readMessageEnd()
5382 
      raise x
5383 
    result = getAllProductFeedSubmit_result()
5384 
    result.read(self._iprot)
5385 
    self._iprot.readMessageEnd()
5386 
    if result.success is not None:
5387 
      return result.success
5388 
    if result.cex is not None:
5389 
      raise result.cex
5390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5391 
 
9724 kshitij.so 5392 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5393 
    """
5394 
    Parameters:
5395 
     - itemId
5396 
     - sourceId
5397 
    """
5398 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5399 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5400 
 
9724 kshitij.so 5401 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5402 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5403 
    args = getMarketplacedetailsForItem_args()
5404 
    args.itemId = itemId
5405 
    args.sourceId = sourceId
5406 
    args.write(self._oprot)
5407 
    self._oprot.writeMessageEnd()
5408 
    self._oprot.trans.flush()
5409 
 
5410 
  def recv_getMarketplacedetailsForItem(self, ):
5411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5412 
    if mtype == TMessageType.EXCEPTION:
5413 
      x = TApplicationException()
5414 
      x.read(self._iprot)
5415 
      self._iprot.readMessageEnd()
5416 
      raise x
5417 
    result = getMarketplacedetailsForItem_result()
5418 
    result.read(self._iprot)
5419 
    self._iprot.readMessageEnd()
5420 
    if result.success is not None:
5421 
      return result.success
5422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5423 
 
5424 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5425 
    """
5426 
    Parameters:
5427 
     - marketPlaceItem
5428 
    """
5429 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5430 
    return self.recv_updateMarketplaceAttributesForItem()
5431 
 
5432 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5433 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5434 
    args = updateMarketplaceAttributesForItem_args()
5435 
    args.marketPlaceItem = marketPlaceItem
5436 
    args.write(self._oprot)
5437 
    self._oprot.writeMessageEnd()
5438 
    self._oprot.trans.flush()
5439 
 
5440 
  def recv_updateMarketplaceAttributesForItem(self, ):
5441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5442 
    if mtype == TMessageType.EXCEPTION:
5443 
      x = TApplicationException()
5444 
      x.read(self._iprot)
5445 
      self._iprot.readMessageEnd()
5446 
      raise x
5447 
    result = updateMarketplaceAttributesForItem_result()
5448 
    result.read(self._iprot)
5449 
    self._iprot.readMessageEnd()
5450 
    if result.success is not None:
5451 
      return result.success
5452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5453 
 
9779 kshitij.so 5454 
  def getCostingForMarketplace(self, source, item_id):
5455 
    """
5456 
    Parameters:
5457 
     - source
5458 
     - item_id
5459 
    """
5460 
    self.send_getCostingForMarketplace(source, item_id)
5461 
    return self.recv_getCostingForMarketplace()
5462 
 
5463 
  def send_getCostingForMarketplace(self, source, item_id):
5464 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5465 
    args = getCostingForMarketplace_args()
5466 
    args.source = source
5467 
    args.item_id = item_id
5468 
    args.write(self._oprot)
5469 
    self._oprot.writeMessageEnd()
5470 
    self._oprot.trans.flush()
5471 
 
5472 
  def recv_getCostingForMarketplace(self, ):
5473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5474 
    if mtype == TMessageType.EXCEPTION:
5475 
      x = TApplicationException()
5476 
      x.read(self._iprot)
5477 
      self._iprot.readMessageEnd()
5478 
      raise x
5479 
    result = getCostingForMarketplace_result()
5480 
    result.read(self._iprot)
5481 
    self._iprot.readMessageEnd()
5482 
    if result.success is not None:
5483 
      return result.success
5484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5485 
 
9776 vikram.rag 5486 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5487 
    """
5488 
    Parameters:
5489 
     - source
5490 
    """
5491 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5492 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5493 
 
9776 vikram.rag 5494 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5495 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5496 
    args = getMarketPlaceItemsForPriceUpdate_args()
5497 
    args.source = source
5498 
    args.write(self._oprot)
5499 
    self._oprot.writeMessageEnd()
5500 
    self._oprot.trans.flush()
5501 
 
5502 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5504 
    if mtype == TMessageType.EXCEPTION:
5505 
      x = TApplicationException()
5506 
      x.read(self._iprot)
5507 
      self._iprot.readMessageEnd()
5508 
      raise x
5509 
    result = getMarketPlaceItemsForPriceUpdate_result()
5510 
    result.read(self._iprot)
5511 
    self._iprot.readMessageEnd()
5512 
    if result.success is not None:
5513 
      return result.success
5514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5515 
 
9816 kshitij.so 5516 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5517 
    """
5518 
    Parameters:
5519 
     - skulist
5520 
     - timestamp
9816 kshitij.so 5521 
     - source
9776 vikram.rag 5522 
    """
9816 kshitij.so 5523 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5524 
    self.recv_updateMarketPlacePriceUpdateStatus()
5525 
 
9816 kshitij.so 5526 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5527 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5528 
    args = updateMarketPlacePriceUpdateStatus_args()
5529 
    args.skulist = skulist
5530 
    args.timestamp = timestamp
9816 kshitij.so 5531 
    args.source = source
9776 vikram.rag 5532 
    args.write(self._oprot)
5533 
    self._oprot.writeMessageEnd()
5534 
    self._oprot.trans.flush()
5535 
 
5536 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5538 
    if mtype == TMessageType.EXCEPTION:
5539 
      x = TApplicationException()
5540 
      x.read(self._iprot)
5541 
      self._iprot.readMessageEnd()
5542 
      raise x
5543 
    result = updateMarketPlacePriceUpdateStatus_result()
5544 
    result.read(self._iprot)
5545 
    self._iprot.readMessageEnd()
5546 
    return
5547 
 
9861 rajveer 5548 
  def updateItemHoldInventory(self, itemHoldMap):
5549 
    """
5550 
    Parameters:
5551 
     - itemHoldMap
5552 
    """
5553 
    self.send_updateItemHoldInventory(itemHoldMap)
5554 
    self.recv_updateItemHoldInventory()
9776 vikram.rag 5555 
 
9861 rajveer 5556 
  def send_updateItemHoldInventory(self, itemHoldMap):
5557 
    self._oprot.writeMessageBegin('updateItemHoldInventory', TMessageType.CALL, self._seqid)
5558 
    args = updateItemHoldInventory_args()
5559 
    args.itemHoldMap = itemHoldMap
5560 
    args.write(self._oprot)
5561 
    self._oprot.writeMessageEnd()
5562 
    self._oprot.trans.flush()
5563 
 
5564 
  def recv_updateItemHoldInventory(self, ):
5565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5566 
    if mtype == TMessageType.EXCEPTION:
5567 
      x = TApplicationException()
5568 
      x.read(self._iprot)
5569 
      self._iprot.readMessageEnd()
5570 
      raise x
5571 
    result = updateItemHoldInventory_result()
5572 
    result.read(self._iprot)
5573 
    self._iprot.readMessageEnd()
5574 
    return
5575 
 
9895 vikram.rag 5576 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5577 
    """
5578 
    Parameters:
5579 
     - item_id
5580 
     - vendor_id
5581 
     - nlc
5582 
    """
5583 
    self.send_updateNlcAtMarketplaces(item_id, vendor_id, nlc)
5584 
    self.recv_updateNlcAtMarketplaces()
9861 rajveer 5585 
 
9895 vikram.rag 5586 
  def send_updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5587 
    self._oprot.writeMessageBegin('updateNlcAtMarketplaces', TMessageType.CALL, self._seqid)
5588 
    args = updateNlcAtMarketplaces_args()
5589 
    args.item_id = item_id
5590 
    args.vendor_id = vendor_id
5591 
    args.nlc = nlc
5592 
    args.write(self._oprot)
5593 
    self._oprot.writeMessageEnd()
5594 
    self._oprot.trans.flush()
5595 
 
5596 
  def recv_updateNlcAtMarketplaces(self, ):
5597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5598 
    if mtype == TMessageType.EXCEPTION:
5599 
      x = TApplicationException()
5600 
      x.read(self._iprot)
5601 
      self._iprot.readMessageEnd()
5602 
      raise x
5603 
    result = updateNlcAtMarketplaces_result()
5604 
    result.read(self._iprot)
5605 
    self._iprot.readMessageEnd()
5606 
    return
5607 
 
9945 vikram.rag 5608 
  def getAllFlipkartItems(self, ):
5609 
    self.send_getAllFlipkartItems()
5610 
    return self.recv_getAllFlipkartItems()
9895 vikram.rag 5611 
 
9945 vikram.rag 5612 
  def send_getAllFlipkartItems(self, ):
5613 
    self._oprot.writeMessageBegin('getAllFlipkartItems', TMessageType.CALL, self._seqid)
5614 
    args = getAllFlipkartItems_args()
5615 
    args.write(self._oprot)
5616 
    self._oprot.writeMessageEnd()
5617 
    self._oprot.trans.flush()
5618 
 
5619 
  def recv_getAllFlipkartItems(self, ):
5620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5621 
    if mtype == TMessageType.EXCEPTION:
5622 
      x = TApplicationException()
5623 
      x.read(self._iprot)
5624 
      self._iprot.readMessageEnd()
5625 
      raise x
5626 
    result = getAllFlipkartItems_result()
5627 
    result.read(self._iprot)
5628 
    self._iprot.readMessageEnd()
5629 
    if result.success is not None:
5630 
      return result.success
5631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartItems failed: unknown result");
5632 
 
10097 kshitij.so 5633 
  def addOrUpdateFlipkartItem(self, flipkartitem):
5634 
    """
5635 
    Parameters:
5636 
     - flipkartitem
5637 
    """
5638 
    self.send_addOrUpdateFlipkartItem(flipkartitem)
5639 
    return self.recv_addOrUpdateFlipkartItem()
9945 vikram.rag 5640 
 
10097 kshitij.so 5641 
  def send_addOrUpdateFlipkartItem(self, flipkartitem):
5642 
    self._oprot.writeMessageBegin('addOrUpdateFlipkartItem', TMessageType.CALL, self._seqid)
5643 
    args = addOrUpdateFlipkartItem_args()
5644 
    args.flipkartitem = flipkartitem
5645 
    args.write(self._oprot)
5646 
    self._oprot.writeMessageEnd()
5647 
    self._oprot.trans.flush()
5648 
 
5649 
  def recv_addOrUpdateFlipkartItem(self, ):
5650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5651 
    if mtype == TMessageType.EXCEPTION:
5652 
      x = TApplicationException()
5653 
      x.read(self._iprot)
5654 
      self._iprot.readMessageEnd()
5655 
      raise x
5656 
    result = addOrUpdateFlipkartItem_result()
5657 
    result.read(self._iprot)
5658 
    self._iprot.readMessageEnd()
5659 
    if result.success is not None:
5660 
      return result.success
5661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateFlipkartItem failed: unknown result");
5662 
 
5663 
  def getFlipkartItem(self, item_id):
5664 
    """
5665 
    Parameters:
5666 
     - item_id
5667 
    """
5668 
    self.send_getFlipkartItem(item_id)
5669 
    return self.recv_getFlipkartItem()
5670 
 
5671 
  def send_getFlipkartItem(self, item_id):
5672 
    self._oprot.writeMessageBegin('getFlipkartItem', TMessageType.CALL, self._seqid)
5673 
    args = getFlipkartItem_args()
5674 
    args.item_id = item_id
5675 
    args.write(self._oprot)
5676 
    self._oprot.writeMessageEnd()
5677 
    self._oprot.trans.flush()
5678 
 
5679 
  def recv_getFlipkartItem(self, ):
5680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5681 
    if mtype == TMessageType.EXCEPTION:
5682 
      x = TApplicationException()
5683 
      x.read(self._iprot)
5684 
      self._iprot.readMessageEnd()
5685 
      raise x
5686 
    result = getFlipkartItem_result()
5687 
    result.read(self._iprot)
5688 
    self._iprot.readMessageEnd()
5689 
    if result.success is not None:
5690 
      return result.success
5691 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItem failed: unknown result");
5692 
 
5693 
  def getFlipkartItemDetails(self, item_id):
5694 
    """
5695 
    Parameters:
5696 
     - item_id
5697 
    """
5698 
    self.send_getFlipkartItemDetails(item_id)
5699 
    return self.recv_getFlipkartItemDetails()
5700 
 
5701 
  def send_getFlipkartItemDetails(self, item_id):
5702 
    self._oprot.writeMessageBegin('getFlipkartItemDetails', TMessageType.CALL, self._seqid)
5703 
    args = getFlipkartItemDetails_args()
5704 
    args.item_id = item_id
5705 
    args.write(self._oprot)
5706 
    self._oprot.writeMessageEnd()
5707 
    self._oprot.trans.flush()
5708 
 
5709 
  def recv_getFlipkartItemDetails(self, ):
5710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5711 
    if mtype == TMessageType.EXCEPTION:
5712 
      x = TApplicationException()
5713 
      x.read(self._iprot)
5714 
      self._iprot.readMessageEnd()
5715 
      raise x
5716 
    result = getFlipkartItemDetails_result()
5717 
    result.read(self._iprot)
5718 
    self._iprot.readMessageEnd()
5719 
    if result.success is not None:
5720 
      return result.success
5721 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemDetails failed: unknown result");
5722 
 
5723 
  def getFlipkartItems(self, offset, limit):
5724 
    """
5725 
    Parameters:
5726 
     - offset
5727 
     - limit
5728 
    """
5729 
    self.send_getFlipkartItems(offset, limit)
5730 
    return self.recv_getFlipkartItems()
5731 
 
5732 
  def send_getFlipkartItems(self, offset, limit):
5733 
    self._oprot.writeMessageBegin('getFlipkartItems', TMessageType.CALL, self._seqid)
5734 
    args = getFlipkartItems_args()
5735 
    args.offset = offset
5736 
    args.limit = limit
5737 
    args.write(self._oprot)
5738 
    self._oprot.writeMessageEnd()
5739 
    self._oprot.trans.flush()
5740 
 
5741 
  def recv_getFlipkartItems(self, ):
5742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5743 
    if mtype == TMessageType.EXCEPTION:
5744 
      x = TApplicationException()
5745 
      x.read(self._iprot)
5746 
      self._iprot.readMessageEnd()
5747 
      raise x
5748 
    result = getFlipkartItems_result()
5749 
    result.read(self._iprot)
5750 
    self._iprot.readMessageEnd()
5751 
    if result.success is not None:
5752 
      return result.success
5753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItems failed: unknown result");
5754 
 
5755 
  def searchFlipkartItems(self, searchTerm, offset, limit):
5756 
    """
5757 
    Parameters:
5758 
     - searchTerm
5759 
     - offset
5760 
     - limit
5761 
    """
5762 
    self.send_searchFlipkartItems(searchTerm, offset, limit)
5763 
    return self.recv_searchFlipkartItems()
5764 
 
5765 
  def send_searchFlipkartItems(self, searchTerm, offset, limit):
5766 
    self._oprot.writeMessageBegin('searchFlipkartItems', TMessageType.CALL, self._seqid)
5767 
    args = searchFlipkartItems_args()
5768 
    args.searchTerm = searchTerm
5769 
    args.offset = offset
5770 
    args.limit = limit
5771 
    args.write(self._oprot)
5772 
    self._oprot.writeMessageEnd()
5773 
    self._oprot.trans.flush()
5774 
 
5775 
  def recv_searchFlipkartItems(self, ):
5776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5777 
    if mtype == TMessageType.EXCEPTION:
5778 
      x = TApplicationException()
5779 
      x.read(self._iprot)
5780 
      self._iprot.readMessageEnd()
5781 
      raise x
5782 
    result = searchFlipkartItems_result()
5783 
    result.read(self._iprot)
5784 
    self._iprot.readMessageEnd()
5785 
    if result.success is not None:
5786 
      return result.success
5787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchFlipkartItems failed: unknown result");
5788 
 
5789 
  def getCountForFlipkartItems(self, ):
5790 
    self.send_getCountForFlipkartItems()
5791 
    return self.recv_getCountForFlipkartItems()
5792 
 
5793 
  def send_getCountForFlipkartItems(self, ):
5794 
    self._oprot.writeMessageBegin('getCountForFlipkartItems', TMessageType.CALL, self._seqid)
5795 
    args = getCountForFlipkartItems_args()
5796 
    args.write(self._oprot)
5797 
    self._oprot.writeMessageEnd()
5798 
    self._oprot.trans.flush()
5799 
 
5800 
  def recv_getCountForFlipkartItems(self, ):
5801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5802 
    if mtype == TMessageType.EXCEPTION:
5803 
      x = TApplicationException()
5804 
      x.read(self._iprot)
5805 
      self._iprot.readMessageEnd()
5806 
      raise x
5807 
    result = getCountForFlipkartItems_result()
5808 
    result.read(self._iprot)
5809 
    self._iprot.readMessageEnd()
5810 
    if result.success is not None:
5811 
      return result.success
5812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForFlipkartItems failed: unknown result");
5813 
 
5814 
  def getFlipkartSearchResultCount(self, searchTerm):
5815 
    """
5816 
    Parameters:
5817 
     - searchTerm
5818 
    """
5819 
    self.send_getFlipkartSearchResultCount(searchTerm)
5820 
    return self.recv_getFlipkartSearchResultCount()
5821 
 
5822 
  def send_getFlipkartSearchResultCount(self, searchTerm):
5823 
    self._oprot.writeMessageBegin('getFlipkartSearchResultCount', TMessageType.CALL, self._seqid)
5824 
    args = getFlipkartSearchResultCount_args()
5825 
    args.searchTerm = searchTerm
5826 
    args.write(self._oprot)
5827 
    self._oprot.writeMessageEnd()
5828 
    self._oprot.trans.flush()
5829 
 
5830 
  def recv_getFlipkartSearchResultCount(self, ):
5831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5832 
    if mtype == TMessageType.EXCEPTION:
5833 
      x = TApplicationException()
5834 
      x.read(self._iprot)
5835 
      self._iprot.readMessageEnd()
5836 
      raise x
5837 
    result = getFlipkartSearchResultCount_result()
5838 
    result.read(self._iprot)
5839 
    self._iprot.readMessageEnd()
5840 
    if result.success is not None:
5841 
      return result.success
5842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartSearchResultCount failed: unknown result");
5843 
 
5844 
  def getAllFkItems(self, ):
5845 
    self.send_getAllFkItems()
5846 
    return self.recv_getAllFkItems()
5847 
 
5848 
  def send_getAllFkItems(self, ):
5849 
    self._oprot.writeMessageBegin('getAllFkItems', TMessageType.CALL, self._seqid)
5850 
    args = getAllFkItems_args()
5851 
    args.write(self._oprot)
5852 
    self._oprot.writeMessageEnd()
5853 
    self._oprot.trans.flush()
5854 
 
5855 
  def recv_getAllFkItems(self, ):
5856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5857 
    if mtype == TMessageType.EXCEPTION:
5858 
      x = TApplicationException()
5859 
      x.read(self._iprot)
5860 
      self._iprot.readMessageEnd()
5861 
      raise x
5862 
    result = getAllFkItems_result()
5863 
    result.read(self._iprot)
5864 
    self._iprot.readMessageEnd()
5865 
    if result.success is not None:
5866 
      return result.success
5867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFkItems failed: unknown result");
5868 
 
10140 vikram.rag 5869 
  def getFlipkartItemBySkyAtFlipkart(self, sku):
5870 
    """
5871 
    Parameters:
5872 
     - sku
5873 
    """
5874 
    self.send_getFlipkartItemBySkyAtFlipkart(sku)
5875 
    return self.recv_getFlipkartItemBySkyAtFlipkart()
10097 kshitij.so 5876 
 
10140 vikram.rag 5877 
  def send_getFlipkartItemBySkyAtFlipkart(self, sku):
5878 
    self._oprot.writeMessageBegin('getFlipkartItemBySkyAtFlipkart', TMessageType.CALL, self._seqid)
5879 
    args = getFlipkartItemBySkyAtFlipkart_args()
5880 
    args.sku = sku
5881 
    args.write(self._oprot)
5882 
    self._oprot.writeMessageEnd()
5883 
    self._oprot.trans.flush()
5884 
 
5885 
  def recv_getFlipkartItemBySkyAtFlipkart(self, ):
5886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5887 
    if mtype == TMessageType.EXCEPTION:
5888 
      x = TApplicationException()
5889 
      x.read(self._iprot)
5890 
      self._iprot.readMessageEnd()
5891 
      raise x
5892 
    result = getFlipkartItemBySkyAtFlipkart_result()
5893 
    result.read(self._iprot)
5894 
    self._iprot.readMessageEnd()
5895 
    if result.success is not None:
5896 
      return result.success
5897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemBySkyAtFlipkart failed: unknown result");
5898 
 
11015 kshitij.so 5899 
  def getMarketplaceHistory(self, source, offset, itemId):
5900 
    """
5901 
    Parameters:
5902 
     - source
5903 
     - offset
5904 
     - itemId
5905 
    """
5906 
    self.send_getMarketplaceHistory(source, offset, itemId)
5907 
    return self.recv_getMarketplaceHistory()
5908 
 
5909 
  def send_getMarketplaceHistory(self, source, offset, itemId):
5910 
    self._oprot.writeMessageBegin('getMarketplaceHistory', TMessageType.CALL, self._seqid)
5911 
    args = getMarketplaceHistory_args()
5912 
    args.source = source
5913 
    args.offset = offset
5914 
    args.itemId = itemId
5915 
    args.write(self._oprot)
5916 
    self._oprot.writeMessageEnd()
5917 
    self._oprot.trans.flush()
5918 
 
5919 
  def recv_getMarketplaceHistory(self, ):
5920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5921 
    if mtype == TMessageType.EXCEPTION:
5922 
      x = TApplicationException()
5923 
      x.read(self._iprot)
5924 
      self._iprot.readMessageEnd()
5925 
      raise x
5926 
    result = getMarketplaceHistory_result()
5927 
    result.read(self._iprot)
5928 
    self._iprot.readMessageEnd()
5929 
    if result.success is not None:
5930 
      return result.success
5931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistory failed: unknown result");
5932 
 
10909 vikram.rag 5933 
  def getAllFbbListedItems(self, ):
5934 
    self.send_getAllFbbListedItems()
5935 
    return self.recv_getAllFbbListedItems()
10140 vikram.rag 5936 
 
10909 vikram.rag 5937 
  def send_getAllFbbListedItems(self, ):
5938 
    self._oprot.writeMessageBegin('getAllFbbListedItems', TMessageType.CALL, self._seqid)
5939 
    args = getAllFbbListedItems_args()
5940 
    args.write(self._oprot)
5941 
    self._oprot.writeMessageEnd()
5942 
    self._oprot.trans.flush()
5943 
 
5944 
  def recv_getAllFbbListedItems(self, ):
5945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5946 
    if mtype == TMessageType.EXCEPTION:
5947 
      x = TApplicationException()
5948 
      x.read(self._iprot)
5949 
      self._iprot.readMessageEnd()
5950 
      raise x
5951 
    result = getAllFbbListedItems_result()
5952 
    result.read(self._iprot)
5953 
    self._iprot.readMessageEnd()
5954 
    if result.success is not None:
5955 
      return result.success
5956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbListedItems failed: unknown result");
5957 
 
10924 vikram.rag 5958 
  def getAllFbbPricingItems(self, ):
5959 
    self.send_getAllFbbPricingItems()
5960 
    return self.recv_getAllFbbPricingItems()
10909 vikram.rag 5961 
 
10924 vikram.rag 5962 
  def send_getAllFbbPricingItems(self, ):
5963 
    self._oprot.writeMessageBegin('getAllFbbPricingItems', TMessageType.CALL, self._seqid)
5964 
    args = getAllFbbPricingItems_args()
5965 
    args.write(self._oprot)
5966 
    self._oprot.writeMessageEnd()
5967 
    self._oprot.trans.flush()
5968 
 
5969 
  def recv_getAllFbbPricingItems(self, ):
5970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5971 
    if mtype == TMessageType.EXCEPTION:
5972 
      x = TApplicationException()
5973 
      x.read(self._iprot)
5974 
      self._iprot.readMessageEnd()
5975 
      raise x
5976 
    result = getAllFbbPricingItems_result()
5977 
    result.read(self._iprot)
5978 
    self._iprot.readMessageEnd()
5979 
    if result.success is not None:
5980 
      return result.success
5981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbPricingItems failed: unknown result");
5982 
 
11015 kshitij.so 5983 
  def getCountForMarketplaceHistory(self, source, itemId):
5984 
    """
5985 
    Parameters:
5986 
     - source
5987 
     - itemId
5988 
    """
5989 
    self.send_getCountForMarketplaceHistory(source, itemId)
5990 
    return self.recv_getCountForMarketplaceHistory()
10924 vikram.rag 5991 
 
11015 kshitij.so 5992 
  def send_getCountForMarketplaceHistory(self, source, itemId):
5993 
    self._oprot.writeMessageBegin('getCountForMarketplaceHistory', TMessageType.CALL, self._seqid)
5994 
    args = getCountForMarketplaceHistory_args()
5995 
    args.source = source
5996 
    args.itemId = itemId
5997 
    args.write(self._oprot)
5998 
    self._oprot.writeMessageEnd()
5999 
    self._oprot.trans.flush()
6000 
 
6001 
  def recv_getCountForMarketplaceHistory(self, ):
6002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6003 
    if mtype == TMessageType.EXCEPTION:
6004 
      x = TApplicationException()
6005 
      x.read(self._iprot)
6006 
      self._iprot.readMessageEnd()
6007 
      raise x
6008 
    result = getCountForMarketplaceHistory_result()
6009 
    result.read(self._iprot)
6010 
    self._iprot.readMessageEnd()
6011 
    if result.success is not None:
6012 
      return result.success
6013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForMarketplaceHistory failed: unknown result");
6014 
 
6015 
  def getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6016 
    """
6017 
    Parameters:
6018 
     - source
6019 
     - startDate
6020 
     - endDate
6021 
     - offset
6022 
     - limit
6023 
     - itemId
6024 
    """
6025 
    self.send_getMarketplaceHistoryByDate(source, startDate, endDate, offset, limit, itemId)
6026 
    return self.recv_getMarketplaceHistoryByDate()
6027 
 
6028 
  def send_getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6029 
    self._oprot.writeMessageBegin('getMarketplaceHistoryByDate', TMessageType.CALL, self._seqid)
6030 
    args = getMarketplaceHistoryByDate_args()
6031 
    args.source = source
6032 
    args.startDate = startDate
6033 
    args.endDate = endDate
6034 
    args.offset = offset
6035 
    args.limit = limit
6036 
    args.itemId = itemId
6037 
    args.write(self._oprot)
6038 
    self._oprot.writeMessageEnd()
6039 
    self._oprot.trans.flush()
6040 
 
6041 
  def recv_getMarketplaceHistoryByDate(self, ):
6042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6043 
    if mtype == TMessageType.EXCEPTION:
6044 
      x = TApplicationException()
6045 
      x.read(self._iprot)
6046 
      self._iprot.readMessageEnd()
6047 
      raise x
6048 
    result = getMarketplaceHistoryByDate_result()
6049 
    result.read(self._iprot)
6050 
    self._iprot.readMessageEnd()
6051 
    if result.success is not None:
6052 
      return result.success
6053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistoryByDate failed: unknown result");
6054 
 
11531 vikram.rag 6055 
  def getPrivateDealDetails(self, item_id):
6056 
    """
6057 
    Parameters:
6058 
     - item_id
6059 
    """
6060 
    self.send_getPrivateDealDetails(item_id)
6061 
    return self.recv_getPrivateDealDetails()
11015 kshitij.so 6062 
 
11531 vikram.rag 6063 
  def send_getPrivateDealDetails(self, item_id):
6064 
    self._oprot.writeMessageBegin('getPrivateDealDetails', TMessageType.CALL, self._seqid)
6065 
    args = getPrivateDealDetails_args()
6066 
    args.item_id = item_id
6067 
    args.write(self._oprot)
6068 
    self._oprot.writeMessageEnd()
6069 
    self._oprot.trans.flush()
6070 
 
6071 
  def recv_getPrivateDealDetails(self, ):
6072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6073 
    if mtype == TMessageType.EXCEPTION:
6074 
      x = TApplicationException()
6075 
      x.read(self._iprot)
6076 
      self._iprot.readMessageEnd()
6077 
      raise x
6078 
    result = getPrivateDealDetails_result()
6079 
    result.read(self._iprot)
6080 
    self._iprot.readMessageEnd()
6081 
    if result.success is not None:
6082 
      return result.success
6083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealDetails failed: unknown result");
6084 
 
6085 
  def getPrivateDealItems(self, offset, limit):
6086 
    """
6087 
    Parameters:
6088 
     - offset
6089 
     - limit
6090 
    """
6091 
    self.send_getPrivateDealItems(offset, limit)
6092 
    return self.recv_getPrivateDealItems()
6093 
 
6094 
  def send_getPrivateDealItems(self, offset, limit):
6095 
    self._oprot.writeMessageBegin('getPrivateDealItems', TMessageType.CALL, self._seqid)
6096 
    args = getPrivateDealItems_args()
6097 
    args.offset = offset
6098 
    args.limit = limit
6099 
    args.write(self._oprot)
6100 
    self._oprot.writeMessageEnd()
6101 
    self._oprot.trans.flush()
6102 
 
6103 
  def recv_getPrivateDealItems(self, ):
6104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6105 
    if mtype == TMessageType.EXCEPTION:
6106 
      x = TApplicationException()
6107 
      x.read(self._iprot)
6108 
      self._iprot.readMessageEnd()
6109 
      raise x
6110 
    result = getPrivateDealItems_result()
6111 
    result.read(self._iprot)
6112 
    self._iprot.readMessageEnd()
6113 
    if result.success is not None:
6114 
      return result.success
6115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealItems failed: unknown result");
6116 
 
11592 amit.gupta 6117 
  def getAllActivePrivateDeals(self, ):
6118 
    self.send_getAllActivePrivateDeals()
6119 
    return self.recv_getAllActivePrivateDeals()
6120 
 
6121 
  def send_getAllActivePrivateDeals(self, ):
6122 
    self._oprot.writeMessageBegin('getAllActivePrivateDeals', TMessageType.CALL, self._seqid)
6123 
    args = getAllActivePrivateDeals_args()
6124 
    args.write(self._oprot)
6125 
    self._oprot.writeMessageEnd()
6126 
    self._oprot.trans.flush()
6127 
 
6128 
  def recv_getAllActivePrivateDeals(self, ):
6129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6130 
    if mtype == TMessageType.EXCEPTION:
6131 
      x = TApplicationException()
6132 
      x.read(self._iprot)
6133 
      self._iprot.readMessageEnd()
6134 
      raise x
6135 
    result = getAllActivePrivateDeals_result()
6136 
    result.read(self._iprot)
6137 
    self._iprot.readMessageEnd()
6138 
    if result.success is not None:
6139 
      return result.success
6140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllActivePrivateDeals failed: unknown result");
6141 
 
11531 vikram.rag 6142 
  def addOrUpdatePrivateDeal(self, privateDeal):
6143 
    """
6144 
    Parameters:
6145 
     - privateDeal
6146 
    """
6147 
    self.send_addOrUpdatePrivateDeal(privateDeal)
6148 
    return self.recv_addOrUpdatePrivateDeal()
6149 
 
6150 
  def send_addOrUpdatePrivateDeal(self, privateDeal):
6151 
    self._oprot.writeMessageBegin('addOrUpdatePrivateDeal', TMessageType.CALL, self._seqid)
6152 
    args = addOrUpdatePrivateDeal_args()
6153 
    args.privateDeal = privateDeal
6154 
    args.write(self._oprot)
6155 
    self._oprot.writeMessageEnd()
6156 
    self._oprot.trans.flush()
6157 
 
6158 
  def recv_addOrUpdatePrivateDeal(self, ):
6159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6160 
    if mtype == TMessageType.EXCEPTION:
6161 
      x = TApplicationException()
6162 
      x.read(self._iprot)
6163 
      self._iprot.readMessageEnd()
6164 
      raise x
6165 
    result = addOrUpdatePrivateDeal_result()
6166 
    result.read(self._iprot)
6167 
    self._iprot.readMessageEnd()
6168 
    if result.success is not None:
6169 
      return result.success
6170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdatePrivateDeal failed: unknown result");
6171 
 
6172 
 
5944 mandeep.dh 6173 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
6174 
  def __init__(self, handler):
6175 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
6176 
    self._processMap["addItem"] = Processor.process_addItem
6177 
    self._processMap["updateItem"] = Processor.process_updateItem
6178 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 6179 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 6180 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
6181 
    self._processMap["startItemOn"] = Processor.process_startItemOn
6182 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
6183 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
6184 
    self._processMap["getItem"] = Processor.process_getItem
6185 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
6186 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
6187 
    self._processMap["getAllItems"] = Processor.process_getAllItems
6188 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
6189 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
6190 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
6191 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
6192 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
6193 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
6194 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
6195 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
6196 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
6197 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
6198 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
6199 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
6200 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
6201 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
6202 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
6203 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
6204 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
6205 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
6206 
    self._processMap["addCategory"] = Processor.process_addCategory
6207 
    self._processMap["getCategory"] = Processor.process_getCategory
6208 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
6209 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
6210 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 6211 
    self._processMap["addTag"] = Processor.process_addTag
6212 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
6213 
    self._processMap["deleteTag"] = Processor.process_deleteTag
6214 
    self._processMap["getAllTags"] = Processor.process_getAllTags
6215 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 6216 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 6217 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 6218 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 6219 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
6220 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
6221 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
6222 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 6223 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 6224 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 6225 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
6226 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 6227 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
6228 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
6229 
    self._processMap["addCampaign"] = Processor.process_addCampaign
6230 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
6231 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
6232 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 6233 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 6234 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
6235 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
6236 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
6237 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
6238 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
6239 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
6240 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
6241 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
6242 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
6243 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
6244 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
6245 
    self._processMap["getAllSources"] = Processor.process_getAllSources
6246 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
6247 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
6248 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
6249 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
6250 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
6251 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
6252 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
6253 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
6254 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
6255 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
6256 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
6257 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
6258 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
6259 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 6260 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
6261 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 6262 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 6263 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 6264 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
6265 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 6266 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 6267 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 6268 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
6269 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 6270 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
6271 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 6272 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 6273 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 6274 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 6275 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 6276 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
6277 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
6278 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 6279 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
6280 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
6281 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 6282 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
6283 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
6284 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 6285 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 6286 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 6287 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 6288 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
6289 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 6290 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
6291 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
6292 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 6293 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 6294 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 6295 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
6296 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 6297 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 6298 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
6299 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 6300 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 6301 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 6302 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
6303 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
6304 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
6305 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 6306 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 6307 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 6308 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
6309 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
6310 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
6311 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
6312 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 6313 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
6314 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 6315 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 6316 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
6317 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
9861 rajveer 6318 
    self._processMap["updateItemHoldInventory"] = Processor.process_updateItemHoldInventory
9895 vikram.rag 6319 
    self._processMap["updateNlcAtMarketplaces"] = Processor.process_updateNlcAtMarketplaces
9945 vikram.rag 6320 
    self._processMap["getAllFlipkartItems"] = Processor.process_getAllFlipkartItems
10097 kshitij.so 6321 
    self._processMap["addOrUpdateFlipkartItem"] = Processor.process_addOrUpdateFlipkartItem
6322 
    self._processMap["getFlipkartItem"] = Processor.process_getFlipkartItem
6323 
    self._processMap["getFlipkartItemDetails"] = Processor.process_getFlipkartItemDetails
6324 
    self._processMap["getFlipkartItems"] = Processor.process_getFlipkartItems
6325 
    self._processMap["searchFlipkartItems"] = Processor.process_searchFlipkartItems
6326 
    self._processMap["getCountForFlipkartItems"] = Processor.process_getCountForFlipkartItems
6327 
    self._processMap["getFlipkartSearchResultCount"] = Processor.process_getFlipkartSearchResultCount
6328 
    self._processMap["getAllFkItems"] = Processor.process_getAllFkItems
10140 vikram.rag 6329 
    self._processMap["getFlipkartItemBySkyAtFlipkart"] = Processor.process_getFlipkartItemBySkyAtFlipkart
11015 kshitij.so 6330 
    self._processMap["getMarketplaceHistory"] = Processor.process_getMarketplaceHistory
10909 vikram.rag 6331 
    self._processMap["getAllFbbListedItems"] = Processor.process_getAllFbbListedItems
10924 vikram.rag 6332 
    self._processMap["getAllFbbPricingItems"] = Processor.process_getAllFbbPricingItems
11015 kshitij.so 6333 
    self._processMap["getCountForMarketplaceHistory"] = Processor.process_getCountForMarketplaceHistory
6334 
    self._processMap["getMarketplaceHistoryByDate"] = Processor.process_getMarketplaceHistoryByDate
11531 vikram.rag 6335 
    self._processMap["getPrivateDealDetails"] = Processor.process_getPrivateDealDetails
6336 
    self._processMap["getPrivateDealItems"] = Processor.process_getPrivateDealItems
11592 amit.gupta 6337 
    self._processMap["getAllActivePrivateDeals"] = Processor.process_getAllActivePrivateDeals
11531 vikram.rag 6338 
    self._processMap["addOrUpdatePrivateDeal"] = Processor.process_addOrUpdatePrivateDeal
5944 mandeep.dh 6339 
 
6340 
  def process(self, iprot, oprot):
6341 
    (name, type, seqid) = iprot.readMessageBegin()
6342 
    if name not in self._processMap:
6343 
      iprot.skip(TType.STRUCT)
6344 
      iprot.readMessageEnd()
6345 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6346 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6347 
      x.write(oprot)
6348 
      oprot.writeMessageEnd()
6349 
      oprot.trans.flush()
6350 
      return
6351 
    else:
6352 
      self._processMap[name](self, seqid, iprot, oprot)
6353 
    return True
6354 
 
6355 
  def process_addItem(self, seqid, iprot, oprot):
6356 
    args = addItem_args()
6357 
    args.read(iprot)
6358 
    iprot.readMessageEnd()
6359 
    result = addItem_result()
6360 
    try:
6361 
      result.success = self._handler.addItem(args.item)
6362 
    except CatalogServiceException, cex:
6363 
      result.cex = cex
6364 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
6365 
    result.write(oprot)
6366 
    oprot.writeMessageEnd()
6367 
    oprot.trans.flush()
6368 
 
6369 
  def process_updateItem(self, seqid, iprot, oprot):
6370 
    args = updateItem_args()
6371 
    args.read(iprot)
6372 
    iprot.readMessageEnd()
6373 
    result = updateItem_result()
6374 
    try:
6375 
      result.success = self._handler.updateItem(args.item)
6376 
    except CatalogServiceException, cex:
6377 
      result.cex = cex
6378 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
6379 
    result.write(oprot)
6380 
    oprot.writeMessageEnd()
6381 
    oprot.trans.flush()
6382 
 
6383 
  def process_isActive(self, seqid, iprot, oprot):
6384 
    args = isActive_args()
6385 
    args.read(iprot)
6386 
    iprot.readMessageEnd()
6387 
    result = isActive_result()
6388 
    try:
6389 
      result.success = self._handler.isActive(args.itemId)
6390 
    except CatalogServiceException, isex:
6391 
      result.isex = isex
6392 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
6393 
    result.write(oprot)
6394 
    oprot.writeMessageEnd()
6395 
    oprot.trans.flush()
6396 
 
7438 amit.gupta 6397 
  def process_getItemsStatus(self, seqid, iprot, oprot):
6398 
    args = getItemsStatus_args()
6399 
    args.read(iprot)
6400 
    iprot.readMessageEnd()
6401 
    result = getItemsStatus_result()
6402 
    try:
6403 
      result.success = self._handler.getItemsStatus(args.itemIds)
6404 
    except CatalogServiceException, isex:
6405 
      result.isex = isex
6406 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
6407 
    result.write(oprot)
6408 
    oprot.writeMessageEnd()
6409 
    oprot.trans.flush()
6410 
 
5944 mandeep.dh 6411 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
6412 
    args = getItemStatusDescription_args()
6413 
    args.read(iprot)
6414 
    iprot.readMessageEnd()
6415 
    result = getItemStatusDescription_result()
6416 
    try:
6417 
      result.success = self._handler.getItemStatusDescription(args.itemId)
6418 
    except CatalogServiceException, isex:
6419 
      result.isex = isex
6420 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
6421 
    result.write(oprot)
6422 
    oprot.writeMessageEnd()
6423 
    oprot.trans.flush()
6424 
 
6425 
  def process_startItemOn(self, seqid, iprot, oprot):
6426 
    args = startItemOn_args()
6427 
    args.read(iprot)
6428 
    iprot.readMessageEnd()
6429 
    result = startItemOn_result()
6430 
    try:
6431 
      self._handler.startItemOn(args.item_id, args.timestamp)
6432 
    except CatalogServiceException, cex:
6433 
      result.cex = cex
6434 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
6435 
    result.write(oprot)
6436 
    oprot.writeMessageEnd()
6437 
    oprot.trans.flush()
6438 
 
6439 
  def process_retireItemOn(self, seqid, iprot, oprot):
6440 
    args = retireItemOn_args()
6441 
    args.read(iprot)
6442 
    iprot.readMessageEnd()
6443 
    result = retireItemOn_result()
6444 
    try:
6445 
      self._handler.retireItemOn(args.item_id, args.timestamp)
6446 
    except CatalogServiceException, cex:
6447 
      result.cex = cex
6448 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
6449 
    result.write(oprot)
6450 
    oprot.writeMessageEnd()
6451 
    oprot.trans.flush()
6452 
 
6453 
  def process_changeItemStatus(self, seqid, iprot, oprot):
6454 
    args = changeItemStatus_args()
6455 
    args.read(iprot)
6456 
    iprot.readMessageEnd()
6457 
    result = changeItemStatus_result()
6458 
    try:
6459 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
6460 
    except CatalogServiceException, cex:
6461 
      result.cex = cex
6462 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
6463 
    result.write(oprot)
6464 
    oprot.writeMessageEnd()
6465 
    oprot.trans.flush()
6466 
 
6467 
  def process_getItem(self, seqid, iprot, oprot):
6468 
    args = getItem_args()
6469 
    args.read(iprot)
6470 
    iprot.readMessageEnd()
6471 
    result = getItem_result()
6472 
    try:
6473 
      result.success = self._handler.getItem(args.item_id)
6474 
    except CatalogServiceException, cex:
6475 
      result.cex = cex
6476 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
6477 
    result.write(oprot)
6478 
    oprot.writeMessageEnd()
6479 
    oprot.trans.flush()
6480 
 
6481 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
6482 
    args = getItemsByCatalogId_args()
6483 
    args.read(iprot)
6484 
    iprot.readMessageEnd()
6485 
    result = getItemsByCatalogId_result()
6486 
    try:
6487 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
6488 
    except CatalogServiceException, cex:
6489 
      result.cex = cex
6490 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
6491 
    result.write(oprot)
6492 
    oprot.writeMessageEnd()
6493 
    oprot.trans.flush()
6494 
 
6495 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
6496 
    args = getValidItemsByCatalogId_args()
6497 
    args.read(iprot)
6498 
    iprot.readMessageEnd()
6499 
    result = getValidItemsByCatalogId_result()
6500 
    try:
6501 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
6502 
    except CatalogServiceException, cex:
6503 
      result.cex = cex
6504 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
6505 
    result.write(oprot)
6506 
    oprot.writeMessageEnd()
6507 
    oprot.trans.flush()
6508 
 
6509 
  def process_getAllItems(self, seqid, iprot, oprot):
6510 
    args = getAllItems_args()
6511 
    args.read(iprot)
6512 
    iprot.readMessageEnd()
6513 
    result = getAllItems_result()
6514 
    try:
6515 
      result.success = self._handler.getAllItems(args.isActive)
6516 
    except CatalogServiceException, cex:
6517 
      result.cex = cex
6518 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
6519 
    result.write(oprot)
6520 
    oprot.writeMessageEnd()
6521 
    oprot.trans.flush()
6522 
 
6523 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
6524 
    args = getAllItemsByStatus_args()
6525 
    args.read(iprot)
6526 
    iprot.readMessageEnd()
6527 
    result = getAllItemsByStatus_result()
6528 
    try:
6529 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
6530 
    except CatalogServiceException, cex:
6531 
      result.cex = cex
6532 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
6533 
    result.write(oprot)
6534 
    oprot.writeMessageEnd()
6535 
    oprot.trans.flush()
6536 
 
6537 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
6538 
    args = markItemAsContentComplete_args()
6539 
    args.read(iprot)
6540 
    iprot.readMessageEnd()
6541 
    result = markItemAsContentComplete_result()
6542 
    try:
9253 rajveer 6543 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 6544 
    except CatalogServiceException, cex:
6545 
      result.cex = cex
6546 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
6547 
    result.write(oprot)
6548 
    oprot.writeMessageEnd()
6549 
    oprot.trans.flush()
6550 
 
6551 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
6552 
    args = getAllItemsInRange_args()
6553 
    args.read(iprot)
6554 
    iprot.readMessageEnd()
6555 
    result = getAllItemsInRange_result()
6556 
    try:
6557 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
6558 
    except CatalogServiceException, cex:
6559 
      result.cex = cex
6560 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
6561 
    result.write(oprot)
6562 
    oprot.writeMessageEnd()
6563 
    oprot.trans.flush()
6564 
 
6565 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
6566 
    args = getAllItemsByStatusInRange_args()
6567 
    args.read(iprot)
6568 
    iprot.readMessageEnd()
6569 
    result = getAllItemsByStatusInRange_result()
6570 
    try:
6571 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
6572 
    except CatalogServiceException, cex:
6573 
      result.cex = cex
6574 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
6575 
    result.write(oprot)
6576 
    oprot.writeMessageEnd()
6577 
    oprot.trans.flush()
6578 
 
6579 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
6580 
    args = getItemCountByStatus_args()
6581 
    args.read(iprot)
6582 
    iprot.readMessageEnd()
6583 
    result = getItemCountByStatus_result()
6584 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
6585 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
6586 
    result.write(oprot)
6587 
    oprot.writeMessageEnd()
6588 
    oprot.trans.flush()
6589 
 
6590 
  def process_getBestSellers(self, seqid, iprot, oprot):
6591 
    args = getBestSellers_args()
6592 
    args.read(iprot)
6593 
    iprot.readMessageEnd()
6594 
    result = getBestSellers_result()
6595 
    try:
6596 
      result.success = self._handler.getBestSellers()
6597 
    except CatalogServiceException, isex:
6598 
      result.isex = isex
6599 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
6600 
    result.write(oprot)
6601 
    oprot.writeMessageEnd()
6602 
    oprot.trans.flush()
6603 
 
6604 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
6605 
    args = getBestSellersCatalogIds_args()
6606 
    args.read(iprot)
6607 
    iprot.readMessageEnd()
6608 
    result = getBestSellersCatalogIds_result()
6609 
    try:
6610 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6611 
    except CatalogServiceException, cex:
6612 
      result.cex = cex
6613 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
6614 
    result.write(oprot)
6615 
    oprot.writeMessageEnd()
6616 
    oprot.trans.flush()
6617 
 
6618 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
6619 
    args = getBestSellersCount_args()
6620 
    args.read(iprot)
6621 
    iprot.readMessageEnd()
6622 
    result = getBestSellersCount_result()
6623 
    try:
6624 
      result.success = self._handler.getBestSellersCount()
6625 
    except CatalogServiceException, cex:
6626 
      result.cex = cex
6627 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
6628 
    result.write(oprot)
6629 
    oprot.writeMessageEnd()
6630 
    oprot.trans.flush()
6631 
 
6632 
  def process_getBestDeals(self, seqid, iprot, oprot):
6633 
    args = getBestDeals_args()
6634 
    args.read(iprot)
6635 
    iprot.readMessageEnd()
6636 
    result = getBestDeals_result()
6637 
    try:
6638 
      result.success = self._handler.getBestDeals()
6639 
    except CatalogServiceException, isex:
6640 
      result.isex = isex
6641 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
6642 
    result.write(oprot)
6643 
    oprot.writeMessageEnd()
6644 
    oprot.trans.flush()
6645 
 
6646 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
6647 
    args = getBestDealsCatalogIds_args()
6648 
    args.read(iprot)
6649 
    iprot.readMessageEnd()
6650 
    result = getBestDealsCatalogIds_result()
6651 
    try:
6652 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6653 
    except CatalogServiceException, cex:
6654 
      result.cex = cex
6655 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
6656 
    result.write(oprot)
6657 
    oprot.writeMessageEnd()
6658 
    oprot.trans.flush()
6659 
 
6660 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
6661 
    args = getBestDealsCount_args()
6662 
    args.read(iprot)
6663 
    iprot.readMessageEnd()
6664 
    result = getBestDealsCount_result()
6665 
    try:
6666 
      result.success = self._handler.getBestDealsCount()
6667 
    except CatalogServiceException, cex:
6668 
      result.cex = cex
6669 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
6670 
    result.write(oprot)
6671 
    oprot.writeMessageEnd()
6672 
    oprot.trans.flush()
6673 
 
6674 
  def process_getComingSoon(self, seqid, iprot, oprot):
6675 
    args = getComingSoon_args()
6676 
    args.read(iprot)
6677 
    iprot.readMessageEnd()
6678 
    result = getComingSoon_result()
6679 
    try:
6680 
      result.success = self._handler.getComingSoon()
6681 
    except CatalogServiceException, isex:
6682 
      result.isex = isex
6683 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
6684 
    result.write(oprot)
6685 
    oprot.writeMessageEnd()
6686 
    oprot.trans.flush()
6687 
 
6688 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
6689 
    args = getComingSoonCatalogIds_args()
6690 
    args.read(iprot)
6691 
    iprot.readMessageEnd()
6692 
    result = getComingSoonCatalogIds_result()
6693 
    try:
6694 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6695 
    except CatalogServiceException, cex:
6696 
      result.cex = cex
6697 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
6698 
    result.write(oprot)
6699 
    oprot.writeMessageEnd()
6700 
    oprot.trans.flush()
6701 
 
6702 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
6703 
    args = getComingSoonCount_args()
6704 
    args.read(iprot)
6705 
    iprot.readMessageEnd()
6706 
    result = getComingSoonCount_result()
6707 
    try:
6708 
      result.success = self._handler.getComingSoonCount()
6709 
    except CatalogServiceException, cex:
6710 
      result.cex = cex
6711 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
6712 
    result.write(oprot)
6713 
    oprot.writeMessageEnd()
6714 
    oprot.trans.flush()
6715 
 
6716 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
6717 
    args = getLatestArrivals_args()
6718 
    args.read(iprot)
6719 
    iprot.readMessageEnd()
6720 
    result = getLatestArrivals_result()
6721 
    try:
6722 
      result.success = self._handler.getLatestArrivals()
6723 
    except CatalogServiceException, isex:
6724 
      result.isex = isex
6725 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
6726 
    result.write(oprot)
6727 
    oprot.writeMessageEnd()
6728 
    oprot.trans.flush()
6729 
 
6730 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
6731 
    args = getLatestArrivalsCatalogIds_args()
6732 
    args.read(iprot)
6733 
    iprot.readMessageEnd()
6734 
    result = getLatestArrivalsCatalogIds_result()
6735 
    try:
6736 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
6737 
    except CatalogServiceException, cex:
6738 
      result.cex = cex
6739 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
6740 
    result.write(oprot)
6741 
    oprot.writeMessageEnd()
6742 
    oprot.trans.flush()
6743 
 
6744 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
6745 
    args = getLatestArrivalsCount_args()
6746 
    args.read(iprot)
6747 
    iprot.readMessageEnd()
6748 
    result = getLatestArrivalsCount_result()
6749 
    try:
6750 
      result.success = self._handler.getLatestArrivalsCount()
6751 
    except CatalogServiceException, cex:
6752 
      result.cex = cex
6753 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
6754 
    result.write(oprot)
6755 
    oprot.writeMessageEnd()
6756 
    oprot.trans.flush()
6757 
 
6758 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
6759 
    args = generateNewEntityID_args()
6760 
    args.read(iprot)
6761 
    iprot.readMessageEnd()
6762 
    result = generateNewEntityID_result()
6763 
    result.success = self._handler.generateNewEntityID()
6764 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
6765 
    result.write(oprot)
6766 
    oprot.writeMessageEnd()
6767 
    oprot.trans.flush()
6768 
 
6769 
  def process_addCategory(self, seqid, iprot, oprot):
6770 
    args = addCategory_args()
6771 
    args.read(iprot)
6772 
    iprot.readMessageEnd()
6773 
    result = addCategory_result()
6774 
    result.success = self._handler.addCategory(args.category)
6775 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
6776 
    result.write(oprot)
6777 
    oprot.writeMessageEnd()
6778 
    oprot.trans.flush()
6779 
 
6780 
  def process_getCategory(self, seqid, iprot, oprot):
6781 
    args = getCategory_args()
6782 
    args.read(iprot)
6783 
    iprot.readMessageEnd()
6784 
    result = getCategory_result()
6785 
    result.success = self._handler.getCategory(args.id)
6786 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
6787 
    result.write(oprot)
6788 
    oprot.writeMessageEnd()
6789 
    oprot.trans.flush()
6790 
 
6791 
  def process_getAllCategories(self, seqid, iprot, oprot):
6792 
    args = getAllCategories_args()
6793 
    args.read(iprot)
6794 
    iprot.readMessageEnd()
6795 
    result = getAllCategories_result()
6796 
    result.success = self._handler.getAllCategories()
6797 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
6798 
    result.write(oprot)
6799 
    oprot.writeMessageEnd()
6800 
    oprot.trans.flush()
6801 
 
6802 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
6803 
    args = getAllSimilarItems_args()
6804 
    args.read(iprot)
6805 
    iprot.readMessageEnd()
6806 
    result = getAllSimilarItems_result()
6807 
    result.success = self._handler.getAllSimilarItems(args.itemId)
6808 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
6809 
    result.write(oprot)
6810 
    oprot.writeMessageEnd()
6811 
    oprot.trans.flush()
6812 
 
6813 
  def process_addSimilarItem(self, seqid, iprot, oprot):
6814 
    args = addSimilarItem_args()
6815 
    args.read(iprot)
6816 
    iprot.readMessageEnd()
6817 
    result = addSimilarItem_result()
6818 
    try:
6819 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
6820 
    except CatalogServiceException, cex:
6821 
      result.cex = cex
6822 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
6823 
    result.write(oprot)
6824 
    oprot.writeMessageEnd()
6825 
    oprot.trans.flush()
6826 
 
6512 kshitij.so 6827 
  def process_addTag(self, seqid, iprot, oprot):
6828 
    args = addTag_args()
6829 
    args.read(iprot)
6830 
    iprot.readMessageEnd()
6831 
    result = addTag_result()
6832 
    result.success = self._handler.addTag(args.displayName, args.itemId)
6833 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
6834 
    result.write(oprot)
6835 
    oprot.writeMessageEnd()
6836 
    oprot.trans.flush()
6837 
 
6838 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
6839 
    args = deleteEntityTag_args()
6840 
    args.read(iprot)
6841 
    iprot.readMessageEnd()
6842 
    result = deleteEntityTag_result()
6843 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
6844 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
6845 
    result.write(oprot)
6846 
    oprot.writeMessageEnd()
6847 
    oprot.trans.flush()
6848 
 
6849 
  def process_deleteTag(self, seqid, iprot, oprot):
6850 
    args = deleteTag_args()
6851 
    args.read(iprot)
6852 
    iprot.readMessageEnd()
6853 
    result = deleteTag_result()
6854 
    result.success = self._handler.deleteTag(args.displayName)
6855 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
6856 
    result.write(oprot)
6857 
    oprot.writeMessageEnd()
6858 
    oprot.trans.flush()
6859 
 
6860 
  def process_getAllTags(self, seqid, iprot, oprot):
6861 
    args = getAllTags_args()
6862 
    args.read(iprot)
6863 
    iprot.readMessageEnd()
6864 
    result = getAllTags_result()
6865 
    result.success = self._handler.getAllTags()
6866 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
6867 
    result.write(oprot)
6868 
    oprot.writeMessageEnd()
6869 
    oprot.trans.flush()
6870 
 
6871 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
6872 
    args = getAllEntitiesByTagName_args()
6873 
    args.read(iprot)
6874 
    iprot.readMessageEnd()
6875 
    result = getAllEntitiesByTagName_result()
6876 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
6877 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
6878 
    result.write(oprot)
6879 
    oprot.writeMessageEnd()
6880 
    oprot.trans.flush()
6881 
 
6845 amit.gupta 6882 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
6883 
    args = getAllEntityTags_args()
6884 
    args.read(iprot)
6885 
    iprot.readMessageEnd()
6886 
    result = getAllEntityTags_result()
6887 
    result.success = self._handler.getAllEntityTags()
6888 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
6889 
    result.write(oprot)
6890 
    oprot.writeMessageEnd()
6891 
    oprot.trans.flush()
6892 
 
6850 kshitij.so 6893 
  def process_addBanner(self, seqid, iprot, oprot):
6894 
    args = addBanner_args()
6895 
    args.read(iprot)
6896 
    iprot.readMessageEnd()
6897 
    result = addBanner_result()
10097 kshitij.so 6898 
    result.success = self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 6899 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
6900 
    result.write(oprot)
6901 
    oprot.writeMessageEnd()
6902 
    oprot.trans.flush()
6903 
 
8579 kshitij.so 6904 
  def process_updateBanner(self, seqid, iprot, oprot):
6905 
    args = updateBanner_args()
6906 
    args.read(iprot)
6907 
    iprot.readMessageEnd()
6908 
    result = updateBanner_result()
6909 
    result.success = self._handler.updateBanner(args.banner)
6910 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
6911 
    result.write(oprot)
6912 
    oprot.writeMessageEnd()
6913 
    oprot.trans.flush()
6914 
 
6850 kshitij.so 6915 
  def process_getAllBanners(self, seqid, iprot, oprot):
6916 
    args = getAllBanners_args()
6917 
    args.read(iprot)
6918 
    iprot.readMessageEnd()
6919 
    result = getAllBanners_result()
6920 
    result.success = self._handler.getAllBanners()
6921 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
6922 
    result.write(oprot)
6923 
    oprot.writeMessageEnd()
6924 
    oprot.trans.flush()
6925 
 
6926 
  def process_deleteBanner(self, seqid, iprot, oprot):
6927 
    args = deleteBanner_args()
6928 
    args.read(iprot)
6929 
    iprot.readMessageEnd()
6930 
    result = deleteBanner_result()
9155 kshitij.so 6931 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 6932 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
6933 
    result.write(oprot)
6934 
    oprot.writeMessageEnd()
6935 
    oprot.trans.flush()
6936 
 
6937 
  def process_getBannerDetails(self, seqid, iprot, oprot):
6938 
    args = getBannerDetails_args()
6939 
    args.read(iprot)
6940 
    iprot.readMessageEnd()
6941 
    result = getBannerDetails_result()
9155 kshitij.so 6942 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 6943 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
6944 
    result.write(oprot)
6945 
    oprot.writeMessageEnd()
6946 
    oprot.trans.flush()
6947 
 
6948 
  def process_getActiveBanners(self, seqid, iprot, oprot):
6949 
    args = getActiveBanners_args()
6950 
    args.read(iprot)
6951 
    iprot.readMessageEnd()
6952 
    result = getActiveBanners_result()
6953 
    result.success = self._handler.getActiveBanners()
6954 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
6955 
    result.write(oprot)
6956 
    oprot.writeMessageEnd()
6957 
    oprot.trans.flush()
6958 
 
6849 kshitij.so 6959 
  def process_addBannerMap(self, seqid, iprot, oprot):
6960 
    args = addBannerMap_args()
6961 
    args.read(iprot)
6962 
    iprot.readMessageEnd()
6963 
    result = addBannerMap_result()
8579 kshitij.so 6964 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 6965 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
6966 
    result.write(oprot)
6967 
    oprot.writeMessageEnd()
6968 
    oprot.trans.flush()
6969 
 
8579 kshitij.so 6970 
  def process_updateBannerMap(self, seqid, iprot, oprot):
6971 
    args = updateBannerMap_args()
6972 
    args.read(iprot)
6973 
    iprot.readMessageEnd()
6974 
    result = updateBannerMap_result()
6975 
    result.success = self._handler.updateBannerMap(args.bannerMap)
6976 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
6977 
    result.write(oprot)
6978 
    oprot.writeMessageEnd()
6979 
    oprot.trans.flush()
6980 
 
6849 kshitij.so 6981 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
6982 
    args = deleteBannerMap_args()
6983 
    args.read(iprot)
6984 
    iprot.readMessageEnd()
6985 
    result = deleteBannerMap_result()
6986 
    result.success = self._handler.deleteBannerMap(args.bannerName)
6987 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
6988 
    result.write(oprot)
6989 
    oprot.writeMessageEnd()
6990 
    oprot.trans.flush()
6991 
 
6992 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
6993 
    args = getBannerMapDetails_args()
6994 
    args.read(iprot)
6995 
    iprot.readMessageEnd()
6996 
    result = getBannerMapDetails_result()
9155 kshitij.so 6997 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 6998 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
6999 
    result.write(oprot)
7000 
    oprot.writeMessageEnd()
7001 
    oprot.trans.flush()
7002 
 
8579 kshitij.so 7003 
  def process_addBannerUri(self, seqid, iprot, oprot):
7004 
    args = addBannerUri_args()
7005 
    args.read(iprot)
7006 
    iprot.readMessageEnd()
7007 
    result = addBannerUri_result()
7008 
    self._handler.addBannerUri(args.bannerUriMappings)
7009 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
7010 
    result.write(oprot)
7011 
    oprot.writeMessageEnd()
7012 
    oprot.trans.flush()
7013 
 
7014 
  def process_getUriMapping(self, seqid, iprot, oprot):
7015 
    args = getUriMapping_args()
7016 
    args.read(iprot)
7017 
    iprot.readMessageEnd()
7018 
    result = getUriMapping_result()
9155 kshitij.so 7019 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 7020 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
7021 
    result.write(oprot)
7022 
    oprot.writeMessageEnd()
7023 
    oprot.trans.flush()
7024 
 
7025 
  def process_addCampaign(self, seqid, iprot, oprot):
7026 
    args = addCampaign_args()
7027 
    args.read(iprot)
7028 
    iprot.readMessageEnd()
7029 
    result = addCampaign_result()
7030 
    self._handler.addCampaign(args.campaign)
7031 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
7032 
    result.write(oprot)
7033 
    oprot.writeMessageEnd()
7034 
    oprot.trans.flush()
7035 
 
7036 
  def process_getCampaigns(self, seqid, iprot, oprot):
7037 
    args = getCampaigns_args()
7038 
    args.read(iprot)
7039 
    iprot.readMessageEnd()
7040 
    result = getCampaigns_result()
7041 
    result.success = self._handler.getCampaigns(args.campaignName)
7042 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
7043 
    result.write(oprot)
7044 
    oprot.writeMessageEnd()
7045 
    oprot.trans.flush()
7046 
 
7047 
  def process_deleteCampaign(self, seqid, iprot, oprot):
7048 
    args = deleteCampaign_args()
7049 
    args.read(iprot)
7050 
    iprot.readMessageEnd()
7051 
    result = deleteCampaign_result()
7052 
    self._handler.deleteCampaign(args.campaignId)
7053 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
7054 
    result.write(oprot)
7055 
    oprot.writeMessageEnd()
7056 
    oprot.trans.flush()
7057 
 
7058 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
7059 
    args = getAllCampaigns_args()
7060 
    args.read(iprot)
7061 
    iprot.readMessageEnd()
7062 
    result = getAllCampaigns_result()
7063 
    result.success = self._handler.getAllCampaigns()
7064 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
7065 
    result.write(oprot)
7066 
    oprot.writeMessageEnd()
7067 
    oprot.trans.flush()
7068 
 
9155 kshitij.so 7069 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
7070 
    args = getActiveBannersForMobileSite_args()
7071 
    args.read(iprot)
7072 
    iprot.readMessageEnd()
7073 
    result = getActiveBannersForMobileSite_result()
7074 
    result.success = self._handler.getActiveBannersForMobileSite()
7075 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
7076 
    result.write(oprot)
7077 
    oprot.writeMessageEnd()
7078 
    oprot.trans.flush()
7079 
 
5944 mandeep.dh 7080 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
7081 
    args = deleteSimilarItem_args()
7082 
    args.read(iprot)
7083 
    iprot.readMessageEnd()
7084 
    result = deleteSimilarItem_result()
7085 
    try:
7086 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
7087 
    except CatalogServiceException, cex:
7088 
      result.cex = cex
7089 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
7090 
    result.write(oprot)
7091 
    oprot.writeMessageEnd()
7092 
    oprot.trans.flush()
7093 
 
7094 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
7095 
    args = checkSimilarItem_args()
7096 
    args.read(iprot)
7097 
    iprot.readMessageEnd()
7098 
    result = checkSimilarItem_result()
7099 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
7100 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
7101 
    result.write(oprot)
7102 
    oprot.writeMessageEnd()
7103 
    oprot.trans.flush()
7104 
 
7105 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
7106 
    args = validateRiskyStatus_args()
7107 
    args.read(iprot)
7108 
    iprot.readMessageEnd()
7109 
    result = validateRiskyStatus_result()
7110 
    self._handler.validateRiskyStatus(args.itemId)
7111 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
7112 
    result.write(oprot)
7113 
    oprot.writeMessageEnd()
7114 
    oprot.trans.flush()
7115 
 
7116 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
7117 
    args = changeItemRiskyFlag_args()
7118 
    args.read(iprot)
7119 
    iprot.readMessageEnd()
7120 
    result = changeItemRiskyFlag_result()
7121 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
7122 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
7123 
    result.write(oprot)
7124 
    oprot.writeMessageEnd()
7125 
    oprot.trans.flush()
7126 
 
7127 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
7128 
    args = getItemsByRiskyFlag_args()
7129 
    args.read(iprot)
7130 
    iprot.readMessageEnd()
7131 
    result = getItemsByRiskyFlag_result()
7132 
    result.success = self._handler.getItemsByRiskyFlag()
7133 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
7134 
    result.write(oprot)
7135 
    oprot.writeMessageEnd()
7136 
    oprot.trans.flush()
7137 
 
7138 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
7139 
    args = getItemsForMasterSheet_args()
7140 
    args.read(iprot)
7141 
    iprot.readMessageEnd()
7142 
    result = getItemsForMasterSheet_result()
7143 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
7144 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
7145 
    result.write(oprot)
7146 
    oprot.writeMessageEnd()
7147 
    oprot.trans.flush()
7148 
 
7149 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
7150 
    args = getSimilarItemsCatalogIds_args()
7151 
    args.read(iprot)
7152 
    iprot.readMessageEnd()
7153 
    result = getSimilarItemsCatalogIds_result()
7154 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
7155 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
7156 
    result.write(oprot)
7157 
    oprot.writeMessageEnd()
7158 
    oprot.trans.flush()
7159 
 
7160 
  def process_addProductNotification(self, seqid, iprot, oprot):
7161 
    args = addProductNotification_args()
7162 
    args.read(iprot)
7163 
    iprot.readMessageEnd()
7164 
    result = addProductNotification_result()
7165 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
7166 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
7167 
    result.write(oprot)
7168 
    oprot.writeMessageEnd()
7169 
    oprot.trans.flush()
7170 
 
7171 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
7172 
    args = sendProductNotifications_args()
7173 
    args.read(iprot)
7174 
    iprot.readMessageEnd()
7175 
    result = sendProductNotifications_result()
7176 
    result.success = self._handler.sendProductNotifications()
7177 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
7178 
    result.write(oprot)
7179 
    oprot.writeMessageEnd()
7180 
    oprot.trans.flush()
7181 
 
7182 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
7183 
    args = getAllBrandsByCategory_args()
7184 
    args.read(iprot)
7185 
    iprot.readMessageEnd()
7186 
    result = getAllBrandsByCategory_result()
7187 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
7188 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
7189 
    result.write(oprot)
7190 
    oprot.writeMessageEnd()
7191 
    oprot.trans.flush()
7192 
 
7193 
  def process_getAllBrands(self, seqid, iprot, oprot):
7194 
    args = getAllBrands_args()
7195 
    args.read(iprot)
7196 
    iprot.readMessageEnd()
7197 
    result = getAllBrands_result()
7198 
    result.success = self._handler.getAllBrands()
7199 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
7200 
    result.write(oprot)
7201 
    oprot.writeMessageEnd()
7202 
    oprot.trans.flush()
7203 
 
7204 
  def process_getAllSources(self, seqid, iprot, oprot):
7205 
    args = getAllSources_args()
7206 
    args.read(iprot)
7207 
    iprot.readMessageEnd()
7208 
    result = getAllSources_result()
7209 
    result.success = self._handler.getAllSources()
7210 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
7211 
    result.write(oprot)
7212 
    oprot.writeMessageEnd()
7213 
    oprot.trans.flush()
7214 
 
7215 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
7216 
    args = getItemPricingBySource_args()
7217 
    args.read(iprot)
7218 
    iprot.readMessageEnd()
7219 
    result = getItemPricingBySource_result()
7220 
    try:
7221 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
7222 
    except CatalogServiceException, cex:
7223 
      result.cex = cex
7224 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
7225 
    result.write(oprot)
7226 
    oprot.writeMessageEnd()
7227 
    oprot.trans.flush()
7228 
 
7229 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
7230 
    args = addSourceItemPricing_args()
7231 
    args.read(iprot)
7232 
    iprot.readMessageEnd()
7233 
    result = addSourceItemPricing_result()
7234 
    try:
7235 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
7236 
    except CatalogServiceException, cex:
7237 
      result.cex = cex
7238 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
7239 
    result.write(oprot)
7240 
    oprot.writeMessageEnd()
7241 
    oprot.trans.flush()
7242 
 
7243 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
7244 
    args = getAllSourcePricing_args()
7245 
    args.read(iprot)
7246 
    iprot.readMessageEnd()
7247 
    result = getAllSourcePricing_result()
7248 
    try:
7249 
      result.success = self._handler.getAllSourcePricing(args.itemId)
7250 
    except CatalogServiceException, cex:
7251 
      result.cex = cex
7252 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
7253 
    result.write(oprot)
7254 
    oprot.writeMessageEnd()
7255 
    oprot.trans.flush()
7256 
 
7257 
  def process_getItemForSource(self, seqid, iprot, oprot):
7258 
    args = getItemForSource_args()
7259 
    args.read(iprot)
7260 
    iprot.readMessageEnd()
7261 
    result = getItemForSource_result()
7262 
    try:
7263 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
7264 
    except CatalogServiceException, cex:
7265 
      result.cex = cex
7266 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
7267 
    result.write(oprot)
7268 
    oprot.writeMessageEnd()
7269 
    oprot.trans.flush()
7270 
 
7271 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
7272 
    args = searchItemsInRange_args()
7273 
    args.read(iprot)
7274 
    iprot.readMessageEnd()
7275 
    result = searchItemsInRange_result()
7276 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
7277 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
7278 
    result.write(oprot)
7279 
    oprot.writeMessageEnd()
7280 
    oprot.trans.flush()
7281 
 
7282 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
7283 
    args = getSearchResultCount_args()
7284 
    args.read(iprot)
7285 
    iprot.readMessageEnd()
7286 
    result = getSearchResultCount_result()
7287 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
7288 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
7289 
    result.write(oprot)
7290 
    oprot.writeMessageEnd()
7291 
    oprot.trans.flush()
7292 
 
7293 
  def process_getProductNotifications(self, seqid, iprot, oprot):
7294 
    args = getProductNotifications_args()
7295 
    args.read(iprot)
7296 
    iprot.readMessageEnd()
7297 
    result = getProductNotifications_result()
7298 
    result.success = self._handler.getProductNotifications(args.startDateTime)
7299 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
7300 
    result.write(oprot)
7301 
    oprot.writeMessageEnd()
7302 
    oprot.trans.flush()
7303 
 
7304 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
7305 
    args = getProductNotificationRequestCount_args()
7306 
    args.read(iprot)
7307 
    iprot.readMessageEnd()
7308 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 7309 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 7310 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
7311 
    result.write(oprot)
7312 
    oprot.writeMessageEnd()
7313 
    oprot.trans.flush()
7314 
 
7315 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
7316 
    args = addAuthorizationLog_args()
7317 
    args.read(iprot)
7318 
    iprot.readMessageEnd()
7319 
    result = addAuthorizationLog_result()
7320 
    try:
7321 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
7322 
    except CatalogServiceException, cex:
7323 
      result.cex = cex
7324 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
7325 
    result.write(oprot)
7326 
    oprot.writeMessageEnd()
7327 
    oprot.trans.flush()
7328 
 
7329 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
7330 
    args = addupdateVoucherForItem_args()
7331 
    args.read(iprot)
7332 
    iprot.readMessageEnd()
7333 
    result = addupdateVoucherForItem_result()
7334 
    try:
7335 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
7336 
    except CatalogServiceException, cex:
7337 
      result.cex = cex
7338 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
7339 
    result.write(oprot)
7340 
    oprot.writeMessageEnd()
7341 
    oprot.trans.flush()
7342 
 
7343 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
7344 
    args = deleteVoucherForItem_args()
7345 
    args.read(iprot)
7346 
    iprot.readMessageEnd()
7347 
    result = deleteVoucherForItem_result()
7348 
    try:
7349 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
7350 
    except CatalogServiceException, cex:
7351 
      result.cex = cex
7352 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
7353 
    result.write(oprot)
7354 
    oprot.writeMessageEnd()
7355 
    oprot.trans.flush()
7356 
 
7357 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
7358 
    args = getVoucherAmount_args()
7359 
    args.read(iprot)
7360 
    iprot.readMessageEnd()
7361 
    result = getVoucherAmount_result()
7362 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
7363 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
7364 
    result.write(oprot)
7365 
    oprot.writeMessageEnd()
7366 
    oprot.trans.flush()
7367 
 
7368 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
7369 
    args = getAllItemVouchers_args()
7370 
    args.read(iprot)
7371 
    iprot.readMessageEnd()
7372 
    result = getAllItemVouchers_result()
7373 
    result.success = self._handler.getAllItemVouchers(args.itemId)
7374 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
7375 
    result.write(oprot)
7376 
    oprot.writeMessageEnd()
7377 
    oprot.trans.flush()
7378 
 
7379 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
7380 
    args = isValidCatalogItemId_args()
7381 
    args.read(iprot)
7382 
    iprot.readMessageEnd()
7383 
    result = isValidCatalogItemId_result()
7384 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
7385 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
7386 
    result.write(oprot)
7387 
    oprot.writeMessageEnd()
7388 
    oprot.trans.flush()
7389 
 
6039 amit.gupta 7390 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
7391 
    args = getVatPercentageForItem_args()
7392 
    args.read(iprot)
7393 
    iprot.readMessageEnd()
7394 
    result = getVatPercentageForItem_result()
7340 amit.gupta 7395 
    try:
7396 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
7397 
    except CatalogServiceException, cex:
7398 
      result.cex = cex
6039 amit.gupta 7399 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
7400 
    result.write(oprot)
7401 
    oprot.writeMessageEnd()
7402 
    oprot.trans.flush()
5944 mandeep.dh 7403 
 
6039 amit.gupta 7404 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
7405 
    args = getVatAmountForItem_args()
7406 
    args.read(iprot)
7407 
    iprot.readMessageEnd()
7408 
    result = getVatAmountForItem_result()
7409 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
7410 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
7411 
    result.write(oprot)
7412 
    oprot.writeMessageEnd()
7413 
    oprot.trans.flush()
7414 
 
6531 vikram.rag 7415 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
7416 
    args = getAllIgnoredInventoryUpdateItemsList_args()
7417 
    args.read(iprot)
7418 
    iprot.readMessageEnd()
7419 
    result = getAllIgnoredInventoryUpdateItemsList_result()
7420 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
7421 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
7422 
    result.write(oprot)
7423 
    oprot.writeMessageEnd()
7424 
    oprot.trans.flush()
6039 amit.gupta 7425 
 
6821 amar.kumar 7426 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
7427 
    args = getAllAliveItems_args()
7428 
    args.read(iprot)
7429 
    iprot.readMessageEnd()
7430 
    result = getAllAliveItems_result()
7431 
    result.success = self._handler.getAllAliveItems()
7432 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
7433 
    result.write(oprot)
7434 
    oprot.writeMessageEnd()
7435 
    oprot.trans.flush()
7436 
 
6805 anupam.sin 7437 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
7438 
    args = getInsuranceAmount_args()
7439 
    args.read(iprot)
7440 
    iprot.readMessageEnd()
7441 
    result = getInsuranceAmount_result()
6921 anupam.sin 7442 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 7443 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
7444 
    result.write(oprot)
7445 
    oprot.writeMessageEnd()
7446 
    oprot.trans.flush()
6531 vikram.rag 7447 
 
6805 anupam.sin 7448 
  def process_getInsurer(self, seqid, iprot, oprot):
7449 
    args = getInsurer_args()
7450 
    args.read(iprot)
7451 
    iprot.readMessageEnd()
7452 
    result = getInsurer_result()
7453 
    result.success = self._handler.getInsurer(args.insurerId)
7454 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
7455 
    result.write(oprot)
7456 
    oprot.writeMessageEnd()
7457 
    oprot.trans.flush()
7458 
 
6838 vikram.rag 7459 
  def process_getAllInsurers(self, seqid, iprot, oprot):
7460 
    args = getAllInsurers_args()
7461 
    args.read(iprot)
7462 
    iprot.readMessageEnd()
7463 
    result = getAllInsurers_result()
7464 
    result.success = self._handler.getAllInsurers()
7465 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
7466 
    result.write(oprot)
7467 
    oprot.writeMessageEnd()
7468 
    oprot.trans.flush()
6805 anupam.sin 7469 
 
6962 rajveer 7470 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
7471 
    args = updateInsuranceDeclaredAmount_args()
7472 
    args.read(iprot)
7473 
    iprot.readMessageEnd()
7474 
    result = updateInsuranceDeclaredAmount_result()
7475 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
7476 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
7477 
    result.write(oprot)
7478 
    oprot.writeMessageEnd()
7479 
    oprot.trans.flush()
6838 vikram.rag 7480 
 
7190 amar.kumar 7481 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
7482 
    args = getFreebieForItem_args()
7483 
    args.read(iprot)
7484 
    iprot.readMessageEnd()
7485 
    result = getFreebieForItem_result()
7486 
    result.success = self._handler.getFreebieForItem(args.itemId)
7487 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
7488 
    result.write(oprot)
7489 
    oprot.writeMessageEnd()
7490 
    oprot.trans.flush()
6962 rajveer 7491 
 
7190 amar.kumar 7492 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
7493 
    args = addOrUpdateFreebieForItem_args()
7494 
    args.read(iprot)
7495 
    iprot.readMessageEnd()
7496 
    result = addOrUpdateFreebieForItem_result()
7497 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
7498 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
7499 
    result.write(oprot)
7500 
    oprot.writeMessageEnd()
7501 
    oprot.trans.flush()
7502 
 
7272 amit.gupta 7503 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
7504 
    args = addOrUpdateBrandInfo_args()
7505 
    args.read(iprot)
7506 
    iprot.readMessageEnd()
7507 
    result = addOrUpdateBrandInfo_result()
7508 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
7509 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
7510 
    result.write(oprot)
7511 
    oprot.writeMessageEnd()
7512 
    oprot.trans.flush()
7513 
 
7514 
  def process_getBrandInfo(self, seqid, iprot, oprot):
7515 
    args = getBrandInfo_args()
7516 
    args.read(iprot)
7517 
    iprot.readMessageEnd()
7518 
    result = getBrandInfo_result()
7519 
    result.success = self._handler.getBrandInfo()
7520 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
7521 
    result.write(oprot)
7522 
    oprot.writeMessageEnd()
7523 
    oprot.trans.flush()
7524 
 
7256 rajveer 7525 
  def process_getStorePricing(self, seqid, iprot, oprot):
7526 
    args = getStorePricing_args()
7527 
    args.read(iprot)
7528 
    iprot.readMessageEnd()
7529 
    result = getStorePricing_result()
7530 
    result.success = self._handler.getStorePricing(args.itemId)
7531 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
7532 
    result.write(oprot)
7533 
    oprot.writeMessageEnd()
7534 
    oprot.trans.flush()
7190 amar.kumar 7535 
 
7306 rajveer 7536 
  def process_getStorePricings(self, seqid, iprot, oprot):
7537 
    args = getStorePricings_args()
7538 
    args.read(iprot)
7539 
    iprot.readMessageEnd()
7540 
    result = getStorePricings_result()
7541 
    result.success = self._handler.getStorePricings(args.itemIds)
7542 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
7543 
    result.write(oprot)
7544 
    oprot.writeMessageEnd()
7545 
    oprot.trans.flush()
7546 
 
7265 rajveer 7547 
  def process_updateStorePricing(self, seqid, iprot, oprot):
7548 
    args = updateStorePricing_args()
7549 
    args.read(iprot)
7550 
    iprot.readMessageEnd()
7551 
    result = updateStorePricing_result()
7382 rajveer 7552 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 7553 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
7554 
    result.write(oprot)
7555 
    oprot.writeMessageEnd()
7556 
    oprot.trans.flush()
7256 rajveer 7557 
 
7281 kshitij.so 7558 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
7559 
    args = getAllAmazonListedItems_args()
7560 
    args.read(iprot)
7561 
    iprot.readMessageEnd()
7562 
    result = getAllAmazonListedItems_result()
7563 
    result.success = self._handler.getAllAmazonListedItems()
7564 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
7565 
    result.write(oprot)
7566 
    oprot.writeMessageEnd()
7567 
    oprot.trans.flush()
7265 rajveer 7568 
 
8619 kshitij.so 7569 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
7570 
    args = searchAmazonItems_args()
7571 
    args.read(iprot)
7572 
    iprot.readMessageEnd()
7573 
    result = searchAmazonItems_result()
7574 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
7575 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
7576 
    result.write(oprot)
7577 
    oprot.writeMessageEnd()
7578 
    oprot.trans.flush()
7579 
 
7580 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
7581 
    args = getAmazonSearchResultCount_args()
7582 
    args.read(iprot)
7583 
    iprot.readMessageEnd()
7584 
    result = getAmazonSearchResultCount_result()
7585 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
7586 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
7587 
    result.write(oprot)
7588 
    oprot.writeMessageEnd()
7589 
    oprot.trans.flush()
7590 
 
7591 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
7592 
    args = getCountForAmazonlistedItems_args()
7593 
    args.read(iprot)
7594 
    iprot.readMessageEnd()
7595 
    result = getCountForAmazonlistedItems_result()
7596 
    result.success = self._handler.getCountForAmazonlistedItems()
7597 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
7598 
    result.write(oprot)
7599 
    oprot.writeMessageEnd()
7600 
    oprot.trans.flush()
7601 
 
7281 kshitij.so 7602 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
7603 
    args = getAmazonItemDetails_args()
7604 
    args.read(iprot)
7605 
    iprot.readMessageEnd()
7606 
    result = getAmazonItemDetails_result()
7607 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
7608 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
7609 
    result.write(oprot)
7610 
    oprot.writeMessageEnd()
7611 
    oprot.trans.flush()
7612 
 
7613 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
7614 
    args = updateAmazonItemDetails_args()
7615 
    args.read(iprot)
7616 
    iprot.readMessageEnd()
7617 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 7618 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 7619 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
7620 
    result.write(oprot)
7621 
    oprot.writeMessageEnd()
7622 
    oprot.trans.flush()
7623 
 
7624 
  def process_addAmazonItem(self, seqid, iprot, oprot):
7625 
    args = addAmazonItem_args()
7626 
    args.read(iprot)
7627 
    iprot.readMessageEnd()
7628 
    result = addAmazonItem_result()
7629 
    self._handler.addAmazonItem(args.amazonlisted)
7630 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
7631 
    result.write(oprot)
7632 
    oprot.writeMessageEnd()
7633 
    oprot.trans.flush()
7634 
 
7291 vikram.rag 7635 
  def process_getAsinItems(self, seqid, iprot, oprot):
7636 
    args = getAsinItems_args()
7637 
    args.read(iprot)
7638 
    iprot.readMessageEnd()
7639 
    result = getAsinItems_result()
7640 
    result.success = self._handler.getAsinItems()
7641 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
7642 
    result.write(oprot)
7643 
    oprot.writeMessageEnd()
7644 
    oprot.trans.flush()
7281 kshitij.so 7645 
 
7291 vikram.rag 7646 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
7647 
    args = getAllFbaListedItems_args()
7648 
    args.read(iprot)
7649 
    iprot.readMessageEnd()
7650 
    result = getAllFbaListedItems_result()
7651 
    result.success = self._handler.getAllFbaListedItems()
7652 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
7653 
    result.write(oprot)
7654 
    oprot.writeMessageEnd()
7655 
    oprot.trans.flush()
7656 
 
7657 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
7658 
    args = getAllNonFbaListedItems_args()
7659 
    args.read(iprot)
7660 
    iprot.readMessageEnd()
7661 
    result = getAllNonFbaListedItems_result()
7662 
    result.success = self._handler.getAllNonFbaListedItems()
7663 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
7664 
    result.write(oprot)
7665 
    oprot.writeMessageEnd()
7666 
    oprot.trans.flush()
7667 
 
7460 kshitij.so 7668 
  def process_updateItemInventory(self, seqid, iprot, oprot):
7669 
    args = updateItemInventory_args()
7670 
    args.read(iprot)
7671 
    iprot.readMessageEnd()
7672 
    result = updateItemInventory_result()
7673 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
7674 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
7675 
    result.write(oprot)
7676 
    oprot.writeMessageEnd()
7677 
    oprot.trans.flush()
7291 vikram.rag 7678 
 
7770 kshitij.so 7679 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
7680 
    args = updateTimestampForAmazonFeeds_args()
7681 
    args.read(iprot)
7682 
    iprot.readMessageEnd()
7683 
    result = updateTimestampForAmazonFeeds_result()
7684 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
7685 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
7686 
    result.write(oprot)
7687 
    oprot.writeMessageEnd()
7688 
    oprot.trans.flush()
7460 kshitij.so 7689 
 
7897 amar.kumar 7690 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
7691 
    args = getAllParentCategories_args()
7692 
    args.read(iprot)
7693 
    iprot.readMessageEnd()
7694 
    result = getAllParentCategories_result()
7695 
    result.success = self._handler.getAllParentCategories()
7696 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
7697 
    result.write(oprot)
7698 
    oprot.writeMessageEnd()
7699 
    oprot.trans.flush()
7770 kshitij.so 7700 
 
7977 kshitij.so 7701 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
7702 
    args = addPageViewEvent_args()
7703 
    args.read(iprot)
7704 
    iprot.readMessageEnd()
7705 
    result = addPageViewEvent_result()
7706 
    self._handler.addPageViewEvent(args.pageViewEvents)
7707 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
7708 
    result.write(oprot)
7709 
    oprot.writeMessageEnd()
7710 
    oprot.trans.flush()
7897 amar.kumar 7711 
 
7977 kshitij.so 7712 
  def process_addCartEvent(self, seqid, iprot, oprot):
7713 
    args = addCartEvent_args()
7714 
    args.read(iprot)
7715 
    iprot.readMessageEnd()
7716 
    result = addCartEvent_result()
7717 
    self._handler.addCartEvent(args.cartEvents)
7718 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
7719 
    result.write(oprot)
7720 
    oprot.writeMessageEnd()
7721 
    oprot.trans.flush()
7722 
 
8182 amar.kumar 7723 
  def process_addEbayItem(self, seqid, iprot, oprot):
7724 
    args = addEbayItem_args()
7725 
    args.read(iprot)
7726 
    iprot.readMessageEnd()
7727 
    result = addEbayItem_result()
7728 
    self._handler.addEbayItem(args.ebayItem)
7729 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
7730 
    result.write(oprot)
7731 
    oprot.writeMessageEnd()
7732 
    oprot.trans.flush()
7733 
 
7734 
  def process_getEbayItem(self, seqid, iprot, oprot):
7735 
    args = getEbayItem_args()
7736 
    args.read(iprot)
7737 
    iprot.readMessageEnd()
7738 
    result = getEbayItem_result()
7739 
    result.success = self._handler.getEbayItem(args.listingId)
7740 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
7741 
    result.write(oprot)
7742 
    oprot.writeMessageEnd()
7743 
    oprot.trans.flush()
7744 
 
7745 
  def process_updateEbayItem(self, seqid, iprot, oprot):
7746 
    args = updateEbayItem_args()
7747 
    args.read(iprot)
7748 
    iprot.readMessageEnd()
7749 
    result = updateEbayItem_result()
7750 
    self._handler.updateEbayItem(args.ebayItem)
7751 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
7752 
    result.write(oprot)
7753 
    oprot.writeMessageEnd()
7754 
    oprot.trans.flush()
7755 
 
8139 kshitij.so 7756 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
7757 
    args = getAmazonListedItems_args()
7758 
    args.read(iprot)
7759 
    iprot.readMessageEnd()
7760 
    result = getAmazonListedItems_result()
7761 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
7762 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
7763 
    result.write(oprot)
7764 
    oprot.writeMessageEnd()
7765 
    oprot.trans.flush()
7977 kshitij.so 7766 
 
8168 kshitij.so 7767 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
7768 
    args = updateAmazonAttributesInBulk_args()
7769 
    args.read(iprot)
7770 
    iprot.readMessageEnd()
7771 
    result = updateAmazonAttributesInBulk_result()
7772 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
7773 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
7774 
    result.write(oprot)
7775 
    oprot.writeMessageEnd()
7776 
    oprot.trans.flush()
8139 kshitij.so 7777 
 
8379 vikram.rag 7778 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
7779 
    args = getAllItemstoListOnFba_args()
7780 
    args.read(iprot)
7781 
    iprot.readMessageEnd()
7782 
    result = getAllItemstoListOnFba_result()
7783 
    result.success = self._handler.getAllItemstoListOnFba()
7784 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
7785 
    result.write(oprot)
7786 
    oprot.writeMessageEnd()
7787 
    oprot.trans.flush()
8168 kshitij.so 7788 
 
8379 vikram.rag 7789 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
7790 
    args = getAllItemstoListOnNonFba_args()
7791 
    args.read(iprot)
7792 
    iprot.readMessageEnd()
7793 
    result = getAllItemstoListOnNonFba_result()
7794 
    result.success = self._handler.getAllItemstoListOnNonFba()
7795 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
7796 
    result.write(oprot)
7797 
    oprot.writeMessageEnd()
7798 
    oprot.trans.flush()
7799 
 
8619 kshitij.so 7800 
  def process_updateAsin(self, seqid, iprot, oprot):
7801 
    args = updateAsin_args()
7802 
    args.read(iprot)
7803 
    iprot.readMessageEnd()
7804 
    result = updateAsin_result()
7805 
    self._handler.updateAsin(args.item)
7806 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
7807 
    result.write(oprot)
7808 
    oprot.writeMessageEnd()
7809 
    oprot.trans.flush()
8616 vikram.rag 7810 
 
8739 vikram.rag 7811 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
7812 
    args = addOrUpdateSnapdealItem_args()
7813 
    args.read(iprot)
7814 
    iprot.readMessageEnd()
7815 
    result = addOrUpdateSnapdealItem_result()
7816 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
7817 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
7818 
    result.write(oprot)
7819 
    oprot.writeMessageEnd()
7820 
    oprot.trans.flush()
8619 kshitij.so 7821 
 
8739 vikram.rag 7822 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
7823 
    args = getSnapdealItem_args()
7824 
    args.read(iprot)
7825 
    iprot.readMessageEnd()
7826 
    result = getSnapdealItem_result()
7827 
    result.success = self._handler.getSnapdealItem(args.item_id)
7828 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
7829 
    result.write(oprot)
7830 
    oprot.writeMessageEnd()
7831 
    oprot.trans.flush()
7832 
 
9242 kshitij.so 7833 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
7834 
    args = getSnapdealItemDetails_args()
7835 
    args.read(iprot)
7836 
    iprot.readMessageEnd()
7837 
    result = getSnapdealItemDetails_result()
7838 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
7839 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
7840 
    result.write(oprot)
7841 
    oprot.writeMessageEnd()
7842 
    oprot.trans.flush()
7843 
 
8739 vikram.rag 7844 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
7845 
    args = getAllSnapdealItems_args()
7846 
    args.read(iprot)
7847 
    iprot.readMessageEnd()
7848 
    result = getAllSnapdealItems_result()
7849 
    result.success = self._handler.getAllSnapdealItems()
7850 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
7851 
    result.write(oprot)
7852 
    oprot.writeMessageEnd()
7853 
    oprot.trans.flush()
7854 
 
9242 kshitij.so 7855 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
7856 
    args = getSnapdealItems_args()
7857 
    args.read(iprot)
7858 
    iprot.readMessageEnd()
7859 
    result = getSnapdealItems_result()
7860 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
7861 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
7862 
    result.write(oprot)
7863 
    oprot.writeMessageEnd()
7864 
    oprot.trans.flush()
8739 vikram.rag 7865 
 
9242 kshitij.so 7866 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
7867 
    args = searchSnapdealItems_args()
7868 
    args.read(iprot)
7869 
    iprot.readMessageEnd()
7870 
    result = searchSnapdealItems_result()
7871 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
7872 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
7873 
    result.write(oprot)
7874 
    oprot.writeMessageEnd()
7875 
    oprot.trans.flush()
7876 
 
7877 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
7878 
    args = getCountForSnapdealItems_args()
7879 
    args.read(iprot)
7880 
    iprot.readMessageEnd()
7881 
    result = getCountForSnapdealItems_result()
7882 
    result.success = self._handler.getCountForSnapdealItems()
7883 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
7884 
    result.write(oprot)
7885 
    oprot.writeMessageEnd()
7886 
    oprot.trans.flush()
7887 
 
7888 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
7889 
    args = getSnapdealSearchResultCount_args()
7890 
    args.read(iprot)
7891 
    iprot.readMessageEnd()
7892 
    result = getSnapdealSearchResultCount_result()
7893 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
7894 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
7895 
    result.write(oprot)
7896 
    oprot.writeMessageEnd()
7897 
    oprot.trans.flush()
7898 
 
9299 kshitij.so 7899 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
7900 
    args = getPrefferedInsurerForItem_args()
7901 
    args.read(iprot)
7902 
    iprot.readMessageEnd()
7903 
    result = getPrefferedInsurerForItem_result()
7904 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
7905 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
7906 
    result.write(oprot)
7907 
    oprot.writeMessageEnd()
7908 
    oprot.trans.flush()
9242 kshitij.so 7909 
 
9456 vikram.rag 7910 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
7911 
    args = getSnapdealItembySkuAtSnapdeal_args()
7912 
    args.read(iprot)
7913 
    iprot.readMessageEnd()
7914 
    result = getSnapdealItembySkuAtSnapdeal_result()
7915 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
7916 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
7917 
    result.write(oprot)
7918 
    oprot.writeMessageEnd()
7919 
    oprot.trans.flush()
9299 kshitij.so 7920 
 
9621 manish.sha 7921 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
7922 
    args = getProductFeedSubmit_args()
7923 
    args.read(iprot)
7924 
    iprot.readMessageEnd()
7925 
    result = getProductFeedSubmit_result()
7926 
    try:
7927 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
7928 
    except CatalogServiceException, cex:
7929 
      result.cex = cex
7930 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
7931 
    result.write(oprot)
7932 
    oprot.writeMessageEnd()
7933 
    oprot.trans.flush()
9456 vikram.rag 7934 
 
9621 manish.sha 7935 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
7936 
    args = addProductFeedSubmit_args()
7937 
    args.read(iprot)
7938 
    iprot.readMessageEnd()
7939 
    result = addProductFeedSubmit_result()
7940 
    try:
7941 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
7942 
    except CatalogServiceException, cex:
7943 
      result.cex = cex
7944 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
7945 
    result.write(oprot)
7946 
    oprot.writeMessageEnd()
7947 
    oprot.trans.flush()
7948 
 
7949 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
7950 
    args = updateProductFeedSubmit_args()
7951 
    args.read(iprot)
7952 
    iprot.readMessageEnd()
7953 
    result = updateProductFeedSubmit_result()
7954 
    try:
7955 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
7956 
    except CatalogServiceException, cex:
7957 
      result.cex = cex
7958 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
7959 
    result.write(oprot)
7960 
    oprot.writeMessageEnd()
7961 
    oprot.trans.flush()
7962 
 
7963 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
7964 
    args = deleteProductFeedSubmit_args()
7965 
    args.read(iprot)
7966 
    iprot.readMessageEnd()
7967 
    result = deleteProductFeedSubmit_result()
7968 
    try:
7969 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
7970 
    except CatalogServiceException, cex:
7971 
      result.cex = cex
7972 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
7973 
    result.write(oprot)
7974 
    oprot.writeMessageEnd()
7975 
    oprot.trans.flush()
7976 
 
7977 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
7978 
    args = getAllProductFeedSubmit_args()
7979 
    args.read(iprot)
7980 
    iprot.readMessageEnd()
7981 
    result = getAllProductFeedSubmit_result()
7982 
    try:
7983 
      result.success = self._handler.getAllProductFeedSubmit()
7984 
    except CatalogServiceException, cex:
7985 
      result.cex = cex
7986 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
7987 
    result.write(oprot)
7988 
    oprot.writeMessageEnd()
7989 
    oprot.trans.flush()
7990 
 
9724 kshitij.so 7991 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
7992 
    args = getMarketplacedetailsForItem_args()
7993 
    args.read(iprot)
7994 
    iprot.readMessageEnd()
7995 
    result = getMarketplacedetailsForItem_result()
7996 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
7997 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
7998 
    result.write(oprot)
7999 
    oprot.writeMessageEnd()
8000 
    oprot.trans.flush()
9621 manish.sha 8001 
 
9724 kshitij.so 8002 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
8003 
    args = updateMarketplaceAttributesForItem_args()
8004 
    args.read(iprot)
8005 
    iprot.readMessageEnd()
8006 
    result = updateMarketplaceAttributesForItem_result()
8007 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
8008 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
8009 
    result.write(oprot)
8010 
    oprot.writeMessageEnd()
8011 
    oprot.trans.flush()
8012 
 
9779 kshitij.so 8013 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
8014 
    args = getCostingForMarketplace_args()
8015 
    args.read(iprot)
8016 
    iprot.readMessageEnd()
8017 
    result = getCostingForMarketplace_result()
8018 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
8019 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
8020 
    result.write(oprot)
8021 
    oprot.writeMessageEnd()
8022 
    oprot.trans.flush()
8023 
 
9776 vikram.rag 8024 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
8025 
    args = getMarketPlaceItemsForPriceUpdate_args()
8026 
    args.read(iprot)
8027 
    iprot.readMessageEnd()
8028 
    result = getMarketPlaceItemsForPriceUpdate_result()
8029 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
8030 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
8031 
    result.write(oprot)
8032 
    oprot.writeMessageEnd()
8033 
    oprot.trans.flush()
9724 kshitij.so 8034 
 
9776 vikram.rag 8035 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
8036 
    args = updateMarketPlacePriceUpdateStatus_args()
8037 
    args.read(iprot)
8038 
    iprot.readMessageEnd()
8039 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 8040 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 8041 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
8042 
    result.write(oprot)
8043 
    oprot.writeMessageEnd()
8044 
    oprot.trans.flush()
8045 
 
9861 rajveer 8046 
  def process_updateItemHoldInventory(self, seqid, iprot, oprot):
8047 
    args = updateItemHoldInventory_args()
8048 
    args.read(iprot)
8049 
    iprot.readMessageEnd()
8050 
    result = updateItemHoldInventory_result()
8051 
    self._handler.updateItemHoldInventory(args.itemHoldMap)
8052 
    oprot.writeMessageBegin("updateItemHoldInventory", TMessageType.REPLY, seqid)
8053 
    result.write(oprot)
8054 
    oprot.writeMessageEnd()
8055 
    oprot.trans.flush()
9776 vikram.rag 8056 
 
9895 vikram.rag 8057 
  def process_updateNlcAtMarketplaces(self, seqid, iprot, oprot):
8058 
    args = updateNlcAtMarketplaces_args()
8059 
    args.read(iprot)
8060 
    iprot.readMessageEnd()
8061 
    result = updateNlcAtMarketplaces_result()
8062 
    self._handler.updateNlcAtMarketplaces(args.item_id, args.vendor_id, args.nlc)
8063 
    oprot.writeMessageBegin("updateNlcAtMarketplaces", TMessageType.REPLY, seqid)
8064 
    result.write(oprot)
8065 
    oprot.writeMessageEnd()
8066 
    oprot.trans.flush()
9861 rajveer 8067 
 
9945 vikram.rag 8068 
  def process_getAllFlipkartItems(self, seqid, iprot, oprot):
8069 
    args = getAllFlipkartItems_args()
8070 
    args.read(iprot)
8071 
    iprot.readMessageEnd()
8072 
    result = getAllFlipkartItems_result()
8073 
    result.success = self._handler.getAllFlipkartItems()
8074 
    oprot.writeMessageBegin("getAllFlipkartItems", TMessageType.REPLY, seqid)
8075 
    result.write(oprot)
8076 
    oprot.writeMessageEnd()
8077 
    oprot.trans.flush()
9895 vikram.rag 8078 
 
10097 kshitij.so 8079 
  def process_addOrUpdateFlipkartItem(self, seqid, iprot, oprot):
8080 
    args = addOrUpdateFlipkartItem_args()
8081 
    args.read(iprot)
8082 
    iprot.readMessageEnd()
8083 
    result = addOrUpdateFlipkartItem_result()
8084 
    result.success = self._handler.addOrUpdateFlipkartItem(args.flipkartitem)
8085 
    oprot.writeMessageBegin("addOrUpdateFlipkartItem", TMessageType.REPLY, seqid)
8086 
    result.write(oprot)
8087 
    oprot.writeMessageEnd()
8088 
    oprot.trans.flush()
9945 vikram.rag 8089 
 
10097 kshitij.so 8090 
  def process_getFlipkartItem(self, seqid, iprot, oprot):
8091 
    args = getFlipkartItem_args()
8092 
    args.read(iprot)
8093 
    iprot.readMessageEnd()
8094 
    result = getFlipkartItem_result()
8095 
    result.success = self._handler.getFlipkartItem(args.item_id)
8096 
    oprot.writeMessageBegin("getFlipkartItem", TMessageType.REPLY, seqid)
8097 
    result.write(oprot)
8098 
    oprot.writeMessageEnd()
8099 
    oprot.trans.flush()
8100 
 
8101 
  def process_getFlipkartItemDetails(self, seqid, iprot, oprot):
8102 
    args = getFlipkartItemDetails_args()
8103 
    args.read(iprot)
8104 
    iprot.readMessageEnd()
8105 
    result = getFlipkartItemDetails_result()
8106 
    result.success = self._handler.getFlipkartItemDetails(args.item_id)
8107 
    oprot.writeMessageBegin("getFlipkartItemDetails", TMessageType.REPLY, seqid)
8108 
    result.write(oprot)
8109 
    oprot.writeMessageEnd()
8110 
    oprot.trans.flush()
8111 
 
8112 
  def process_getFlipkartItems(self, seqid, iprot, oprot):
8113 
    args = getFlipkartItems_args()
8114 
    args.read(iprot)
8115 
    iprot.readMessageEnd()
8116 
    result = getFlipkartItems_result()
8117 
    result.success = self._handler.getFlipkartItems(args.offset, args.limit)
8118 
    oprot.writeMessageBegin("getFlipkartItems", TMessageType.REPLY, seqid)
8119 
    result.write(oprot)
8120 
    oprot.writeMessageEnd()
8121 
    oprot.trans.flush()
8122 
 
8123 
  def process_searchFlipkartItems(self, seqid, iprot, oprot):
8124 
    args = searchFlipkartItems_args()
8125 
    args.read(iprot)
8126 
    iprot.readMessageEnd()
8127 
    result = searchFlipkartItems_result()
8128 
    result.success = self._handler.searchFlipkartItems(args.searchTerm, args.offset, args.limit)
8129 
    oprot.writeMessageBegin("searchFlipkartItems", TMessageType.REPLY, seqid)
8130 
    result.write(oprot)
8131 
    oprot.writeMessageEnd()
8132 
    oprot.trans.flush()
8133 
 
8134 
  def process_getCountForFlipkartItems(self, seqid, iprot, oprot):
8135 
    args = getCountForFlipkartItems_args()
8136 
    args.read(iprot)
8137 
    iprot.readMessageEnd()
8138 
    result = getCountForFlipkartItems_result()
8139 
    result.success = self._handler.getCountForFlipkartItems()
8140 
    oprot.writeMessageBegin("getCountForFlipkartItems", TMessageType.REPLY, seqid)
8141 
    result.write(oprot)
8142 
    oprot.writeMessageEnd()
8143 
    oprot.trans.flush()
8144 
 
8145 
  def process_getFlipkartSearchResultCount(self, seqid, iprot, oprot):
8146 
    args = getFlipkartSearchResultCount_args()
8147 
    args.read(iprot)
8148 
    iprot.readMessageEnd()
8149 
    result = getFlipkartSearchResultCount_result()
8150 
    result.success = self._handler.getFlipkartSearchResultCount(args.searchTerm)
8151 
    oprot.writeMessageBegin("getFlipkartSearchResultCount", TMessageType.REPLY, seqid)
8152 
    result.write(oprot)
8153 
    oprot.writeMessageEnd()
8154 
    oprot.trans.flush()
8155 
 
8156 
  def process_getAllFkItems(self, seqid, iprot, oprot):
8157 
    args = getAllFkItems_args()
8158 
    args.read(iprot)
8159 
    iprot.readMessageEnd()
8160 
    result = getAllFkItems_result()
8161 
    result.success = self._handler.getAllFkItems()
8162 
    oprot.writeMessageBegin("getAllFkItems", TMessageType.REPLY, seqid)
8163 
    result.write(oprot)
8164 
    oprot.writeMessageEnd()
8165 
    oprot.trans.flush()
8166 
 
10140 vikram.rag 8167 
  def process_getFlipkartItemBySkyAtFlipkart(self, seqid, iprot, oprot):
8168 
    args = getFlipkartItemBySkyAtFlipkart_args()
8169 
    args.read(iprot)
8170 
    iprot.readMessageEnd()
8171 
    result = getFlipkartItemBySkyAtFlipkart_result()
8172 
    result.success = self._handler.getFlipkartItemBySkyAtFlipkart(args.sku)
8173 
    oprot.writeMessageBegin("getFlipkartItemBySkyAtFlipkart", TMessageType.REPLY, seqid)
8174 
    result.write(oprot)
8175 
    oprot.writeMessageEnd()
8176 
    oprot.trans.flush()
10097 kshitij.so 8177 
 
11015 kshitij.so 8178 
  def process_getMarketplaceHistory(self, seqid, iprot, oprot):
8179 
    args = getMarketplaceHistory_args()
8180 
    args.read(iprot)
8181 
    iprot.readMessageEnd()
8182 
    result = getMarketplaceHistory_result()
8183 
    result.success = self._handler.getMarketplaceHistory(args.source, args.offset, args.itemId)
8184 
    oprot.writeMessageBegin("getMarketplaceHistory", TMessageType.REPLY, seqid)
8185 
    result.write(oprot)
8186 
    oprot.writeMessageEnd()
8187 
    oprot.trans.flush()
8188 
 
10909 vikram.rag 8189 
  def process_getAllFbbListedItems(self, seqid, iprot, oprot):
8190 
    args = getAllFbbListedItems_args()
8191 
    args.read(iprot)
8192 
    iprot.readMessageEnd()
8193 
    result = getAllFbbListedItems_result()
8194 
    result.success = self._handler.getAllFbbListedItems()
8195 
    oprot.writeMessageBegin("getAllFbbListedItems", TMessageType.REPLY, seqid)
8196 
    result.write(oprot)
8197 
    oprot.writeMessageEnd()
8198 
    oprot.trans.flush()
10140 vikram.rag 8199 
 
10924 vikram.rag 8200 
  def process_getAllFbbPricingItems(self, seqid, iprot, oprot):
8201 
    args = getAllFbbPricingItems_args()
8202 
    args.read(iprot)
8203 
    iprot.readMessageEnd()
8204 
    result = getAllFbbPricingItems_result()
8205 
    result.success = self._handler.getAllFbbPricingItems()
8206 
    oprot.writeMessageBegin("getAllFbbPricingItems", TMessageType.REPLY, seqid)
8207 
    result.write(oprot)
8208 
    oprot.writeMessageEnd()
8209 
    oprot.trans.flush()
10909 vikram.rag 8210 
 
11015 kshitij.so 8211 
  def process_getCountForMarketplaceHistory(self, seqid, iprot, oprot):
8212 
    args = getCountForMarketplaceHistory_args()
8213 
    args.read(iprot)
8214 
    iprot.readMessageEnd()
8215 
    result = getCountForMarketplaceHistory_result()
8216 
    result.success = self._handler.getCountForMarketplaceHistory(args.source, args.itemId)
8217 
    oprot.writeMessageBegin("getCountForMarketplaceHistory", TMessageType.REPLY, seqid)
8218 
    result.write(oprot)
8219 
    oprot.writeMessageEnd()
8220 
    oprot.trans.flush()
10924 vikram.rag 8221 
 
11015 kshitij.so 8222 
  def process_getMarketplaceHistoryByDate(self, seqid, iprot, oprot):
8223 
    args = getMarketplaceHistoryByDate_args()
8224 
    args.read(iprot)
8225 
    iprot.readMessageEnd()
8226 
    result = getMarketplaceHistoryByDate_result()
8227 
    result.success = self._handler.getMarketplaceHistoryByDate(args.source, args.startDate, args.endDate, args.offset, args.limit, args.itemId)
8228 
    oprot.writeMessageBegin("getMarketplaceHistoryByDate", TMessageType.REPLY, seqid)
8229 
    result.write(oprot)
8230 
    oprot.writeMessageEnd()
8231 
    oprot.trans.flush()
8232 
 
11531 vikram.rag 8233 
  def process_getPrivateDealDetails(self, seqid, iprot, oprot):
8234 
    args = getPrivateDealDetails_args()
8235 
    args.read(iprot)
8236 
    iprot.readMessageEnd()
8237 
    result = getPrivateDealDetails_result()
8238 
    result.success = self._handler.getPrivateDealDetails(args.item_id)
8239 
    oprot.writeMessageBegin("getPrivateDealDetails", TMessageType.REPLY, seqid)
8240 
    result.write(oprot)
8241 
    oprot.writeMessageEnd()
8242 
    oprot.trans.flush()
11015 kshitij.so 8243 
 
11531 vikram.rag 8244 
  def process_getPrivateDealItems(self, seqid, iprot, oprot):
8245 
    args = getPrivateDealItems_args()
8246 
    args.read(iprot)
8247 
    iprot.readMessageEnd()
8248 
    result = getPrivateDealItems_result()
8249 
    result.success = self._handler.getPrivateDealItems(args.offset, args.limit)
8250 
    oprot.writeMessageBegin("getPrivateDealItems", TMessageType.REPLY, seqid)
8251 
    result.write(oprot)
8252 
    oprot.writeMessageEnd()
8253 
    oprot.trans.flush()
8254 
 
11592 amit.gupta 8255 
  def process_getAllActivePrivateDeals(self, seqid, iprot, oprot):
8256 
    args = getAllActivePrivateDeals_args()
8257 
    args.read(iprot)
8258 
    iprot.readMessageEnd()
8259 
    result = getAllActivePrivateDeals_result()
8260 
    result.success = self._handler.getAllActivePrivateDeals()
8261 
    oprot.writeMessageBegin("getAllActivePrivateDeals", TMessageType.REPLY, seqid)
8262 
    result.write(oprot)
8263 
    oprot.writeMessageEnd()
8264 
    oprot.trans.flush()
8265 
 
11531 vikram.rag 8266 
  def process_addOrUpdatePrivateDeal(self, seqid, iprot, oprot):
8267 
    args = addOrUpdatePrivateDeal_args()
8268 
    args.read(iprot)
8269 
    iprot.readMessageEnd()
8270 
    result = addOrUpdatePrivateDeal_result()
8271 
    result.success = self._handler.addOrUpdatePrivateDeal(args.privateDeal)
8272 
    oprot.writeMessageBegin("addOrUpdatePrivateDeal", TMessageType.REPLY, seqid)
8273 
    result.write(oprot)
8274 
    oprot.writeMessageEnd()
8275 
    oprot.trans.flush()
8276 
 
8277 
 
5944 mandeep.dh 8278 
# HELPER FUNCTIONS AND STRUCTURES
8279 
 
8280 
class addItem_args:
8281 
  """
8282 
  Attributes:
8283 
   - item
8284 
  """
8285 
 
8286 
  thrift_spec = (
8287 
    None, # 0
8288 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
8289 
  )
8290 
 
8291 
  def __init__(self, item=None,):
8292 
    self.item = item
8293 
 
8294 
  def read(self, iprot):
8295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8297 
      return
8298 
    iprot.readStructBegin()
8299 
    while True:
8300 
      (fname, ftype, fid) = iprot.readFieldBegin()
8301 
      if ftype == TType.STOP:
8302 
        break
8303 
      if fid == 1:
8304 
        if ftype == TType.STRUCT:
8305 
          self.item = Item()
8306 
          self.item.read(iprot)
8307 
        else:
8308 
          iprot.skip(ftype)
8309 
      else:
8310 
        iprot.skip(ftype)
8311 
      iprot.readFieldEnd()
8312 
    iprot.readStructEnd()
8313 
 
8314 
  def write(self, oprot):
8315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8317 
      return
8318 
    oprot.writeStructBegin('addItem_args')
8319 
    if self.item is not None:
8320 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
8321 
      self.item.write(oprot)
8322 
      oprot.writeFieldEnd()
8323 
    oprot.writeFieldStop()
8324 
    oprot.writeStructEnd()
8325 
 
8326 
  def validate(self):
8327 
    return
8328 
 
8329 
 
8330 
  def __repr__(self):
8331 
    L = ['%s=%r' % (key, value)
8332 
      for key, value in self.__dict__.iteritems()]
8333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8334 
 
8335 
  def __eq__(self, other):
8336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8337 
 
8338 
  def __ne__(self, other):
8339 
    return not (self == other)
8340 
 
8341 
class addItem_result:
8342 
  """
8343 
  Attributes:
8344 
   - success
8345 
   - cex
8346 
  """
8347 
 
8348 
  thrift_spec = (
8349 
    (0, TType.I64, 'success', None, None, ), # 0
8350 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8351 
  )
8352 
 
8353 
  def __init__(self, success=None, cex=None,):
8354 
    self.success = success
8355 
    self.cex = cex
8356 
 
8357 
  def read(self, iprot):
8358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8360 
      return
8361 
    iprot.readStructBegin()
8362 
    while True:
8363 
      (fname, ftype, fid) = iprot.readFieldBegin()
8364 
      if ftype == TType.STOP:
8365 
        break
8366 
      if fid == 0:
8367 
        if ftype == TType.I64:
8368 
          self.success = iprot.readI64();
8369 
        else:
8370 
          iprot.skip(ftype)
8371 
      elif fid == 1:
8372 
        if ftype == TType.STRUCT:
8373 
          self.cex = CatalogServiceException()
8374 
          self.cex.read(iprot)
8375 
        else:
8376 
          iprot.skip(ftype)
8377 
      else:
8378 
        iprot.skip(ftype)
8379 
      iprot.readFieldEnd()
8380 
    iprot.readStructEnd()
8381 
 
8382 
  def write(self, oprot):
8383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8385 
      return
8386 
    oprot.writeStructBegin('addItem_result')
8387 
    if self.success is not None:
8388 
      oprot.writeFieldBegin('success', TType.I64, 0)
8389 
      oprot.writeI64(self.success)
8390 
      oprot.writeFieldEnd()
8391 
    if self.cex is not None:
8392 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8393 
      self.cex.write(oprot)
8394 
      oprot.writeFieldEnd()
8395 
    oprot.writeFieldStop()
8396 
    oprot.writeStructEnd()
8397 
 
8398 
  def validate(self):
8399 
    return
8400 
 
8401 
 
8402 
  def __repr__(self):
8403 
    L = ['%s=%r' % (key, value)
8404 
      for key, value in self.__dict__.iteritems()]
8405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8406 
 
8407 
  def __eq__(self, other):
8408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8409 
 
8410 
  def __ne__(self, other):
8411 
    return not (self == other)
8412 
 
8413 
class updateItem_args:
8414 
  """
8415 
  Attributes:
8416 
   - item
8417 
  """
8418 
 
8419 
  thrift_spec = (
8420 
    None, # 0
8421 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
8422 
  )
8423 
 
8424 
  def __init__(self, item=None,):
8425 
    self.item = item
8426 
 
8427 
  def read(self, iprot):
8428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8430 
      return
8431 
    iprot.readStructBegin()
8432 
    while True:
8433 
      (fname, ftype, fid) = iprot.readFieldBegin()
8434 
      if ftype == TType.STOP:
8435 
        break
8436 
      if fid == 1:
8437 
        if ftype == TType.STRUCT:
8438 
          self.item = Item()
8439 
          self.item.read(iprot)
8440 
        else:
8441 
          iprot.skip(ftype)
8442 
      else:
8443 
        iprot.skip(ftype)
8444 
      iprot.readFieldEnd()
8445 
    iprot.readStructEnd()
8446 
 
8447 
  def write(self, oprot):
8448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8450 
      return
8451 
    oprot.writeStructBegin('updateItem_args')
8452 
    if self.item is not None:
8453 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
8454 
      self.item.write(oprot)
8455 
      oprot.writeFieldEnd()
8456 
    oprot.writeFieldStop()
8457 
    oprot.writeStructEnd()
8458 
 
8459 
  def validate(self):
8460 
    return
8461 
 
8462 
 
8463 
  def __repr__(self):
8464 
    L = ['%s=%r' % (key, value)
8465 
      for key, value in self.__dict__.iteritems()]
8466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8467 
 
8468 
  def __eq__(self, other):
8469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8470 
 
8471 
  def __ne__(self, other):
8472 
    return not (self == other)
8473 
 
8474 
class updateItem_result:
8475 
  """
8476 
  Attributes:
8477 
   - success
8478 
   - cex
8479 
  """
8480 
 
8481 
  thrift_spec = (
8482 
    (0, TType.I64, 'success', None, None, ), # 0
8483 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8484 
  )
8485 
 
8486 
  def __init__(self, success=None, cex=None,):
8487 
    self.success = success
8488 
    self.cex = cex
8489 
 
8490 
  def read(self, iprot):
8491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8493 
      return
8494 
    iprot.readStructBegin()
8495 
    while True:
8496 
      (fname, ftype, fid) = iprot.readFieldBegin()
8497 
      if ftype == TType.STOP:
8498 
        break
8499 
      if fid == 0:
8500 
        if ftype == TType.I64:
8501 
          self.success = iprot.readI64();
8502 
        else:
8503 
          iprot.skip(ftype)
8504 
      elif fid == 1:
8505 
        if ftype == TType.STRUCT:
8506 
          self.cex = CatalogServiceException()
8507 
          self.cex.read(iprot)
8508 
        else:
8509 
          iprot.skip(ftype)
8510 
      else:
8511 
        iprot.skip(ftype)
8512 
      iprot.readFieldEnd()
8513 
    iprot.readStructEnd()
8514 
 
8515 
  def write(self, oprot):
8516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8518 
      return
8519 
    oprot.writeStructBegin('updateItem_result')
8520 
    if self.success is not None:
8521 
      oprot.writeFieldBegin('success', TType.I64, 0)
8522 
      oprot.writeI64(self.success)
8523 
      oprot.writeFieldEnd()
8524 
    if self.cex is not None:
8525 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8526 
      self.cex.write(oprot)
8527 
      oprot.writeFieldEnd()
8528 
    oprot.writeFieldStop()
8529 
    oprot.writeStructEnd()
8530 
 
8531 
  def validate(self):
8532 
    return
8533 
 
8534 
 
8535 
  def __repr__(self):
8536 
    L = ['%s=%r' % (key, value)
8537 
      for key, value in self.__dict__.iteritems()]
8538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8539 
 
8540 
  def __eq__(self, other):
8541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8542 
 
8543 
  def __ne__(self, other):
8544 
    return not (self == other)
8545 
 
8546 
class isActive_args:
8547 
  """
8548 
  Attributes:
8549 
   - itemId
8550 
  """
8551 
 
8552 
  thrift_spec = (
8553 
    None, # 0
8554 
    (1, TType.I64, 'itemId', None, None, ), # 1
8555 
  )
8556 
 
8557 
  def __init__(self, itemId=None,):
8558 
    self.itemId = itemId
8559 
 
8560 
  def read(self, iprot):
8561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8563 
      return
8564 
    iprot.readStructBegin()
8565 
    while True:
8566 
      (fname, ftype, fid) = iprot.readFieldBegin()
8567 
      if ftype == TType.STOP:
8568 
        break
8569 
      if fid == 1:
8570 
        if ftype == TType.I64:
8571 
          self.itemId = iprot.readI64();
8572 
        else:
8573 
          iprot.skip(ftype)
8574 
      else:
8575 
        iprot.skip(ftype)
8576 
      iprot.readFieldEnd()
8577 
    iprot.readStructEnd()
8578 
 
8579 
  def write(self, oprot):
8580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8582 
      return
8583 
    oprot.writeStructBegin('isActive_args')
8584 
    if self.itemId is not None:
8585 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8586 
      oprot.writeI64(self.itemId)
8587 
      oprot.writeFieldEnd()
8588 
    oprot.writeFieldStop()
8589 
    oprot.writeStructEnd()
8590 
 
8591 
  def validate(self):
8592 
    return
8593 
 
8594 
 
8595 
  def __repr__(self):
8596 
    L = ['%s=%r' % (key, value)
8597 
      for key, value in self.__dict__.iteritems()]
8598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8599 
 
8600 
  def __eq__(self, other):
8601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8602 
 
8603 
  def __ne__(self, other):
8604 
    return not (self == other)
8605 
 
8606 
class isActive_result:
8607 
  """
8608 
  Attributes:
8609 
   - success
8610 
   - isex
8611 
  """
8612 
 
8613 
  thrift_spec = (
8614 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
8615 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8616 
  )
8617 
 
8618 
  def __init__(self, success=None, isex=None,):
8619 
    self.success = success
8620 
    self.isex = isex
8621 
 
8622 
  def read(self, iprot):
8623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8625 
      return
8626 
    iprot.readStructBegin()
8627 
    while True:
8628 
      (fname, ftype, fid) = iprot.readFieldBegin()
8629 
      if ftype == TType.STOP:
8630 
        break
8631 
      if fid == 0:
8632 
        if ftype == TType.STRUCT:
8633 
          self.success = ItemShippingInfo()
8634 
          self.success.read(iprot)
8635 
        else:
8636 
          iprot.skip(ftype)
8637 
      elif fid == 1:
8638 
        if ftype == TType.STRUCT:
8639 
          self.isex = CatalogServiceException()
8640 
          self.isex.read(iprot)
8641 
        else:
8642 
          iprot.skip(ftype)
8643 
      else:
8644 
        iprot.skip(ftype)
8645 
      iprot.readFieldEnd()
8646 
    iprot.readStructEnd()
8647 
 
8648 
  def write(self, oprot):
8649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8651 
      return
8652 
    oprot.writeStructBegin('isActive_result')
8653 
    if self.success is not None:
8654 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8655 
      self.success.write(oprot)
8656 
      oprot.writeFieldEnd()
8657 
    if self.isex is not None:
8658 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8659 
      self.isex.write(oprot)
8660 
      oprot.writeFieldEnd()
8661 
    oprot.writeFieldStop()
8662 
    oprot.writeStructEnd()
8663 
 
8664 
  def validate(self):
8665 
    return
8666 
 
8667 
 
8668 
  def __repr__(self):
8669 
    L = ['%s=%r' % (key, value)
8670 
      for key, value in self.__dict__.iteritems()]
8671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8672 
 
8673 
  def __eq__(self, other):
8674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8675 
 
8676 
  def __ne__(self, other):
8677 
    return not (self == other)
8678 
 
7438 amit.gupta 8679 
class getItemsStatus_args:
8680 
  """
8681 
  Attributes:
8682 
   - itemIds
8683 
  """
8684 
 
8685 
  thrift_spec = (
8686 
    None, # 0
8687 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
8688 
  )
8689 
 
8690 
  def __init__(self, itemIds=None,):
8691 
    self.itemIds = itemIds
8692 
 
8693 
  def read(self, iprot):
8694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8696 
      return
8697 
    iprot.readStructBegin()
8698 
    while True:
8699 
      (fname, ftype, fid) = iprot.readFieldBegin()
8700 
      if ftype == TType.STOP:
8701 
        break
8702 
      if fid == 1:
8703 
        if ftype == TType.LIST:
8704 
          self.itemIds = []
8590 kshitij.so 8705 
          (_etype33, _size30) = iprot.readListBegin()
8706 
          for _i34 in xrange(_size30):
8707 
            _elem35 = iprot.readI64();
8708 
            self.itemIds.append(_elem35)
7438 amit.gupta 8709 
          iprot.readListEnd()
8710 
        else:
8711 
          iprot.skip(ftype)
8712 
      else:
8713 
        iprot.skip(ftype)
8714 
      iprot.readFieldEnd()
8715 
    iprot.readStructEnd()
8716 
 
8717 
  def write(self, oprot):
8718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8720 
      return
8721 
    oprot.writeStructBegin('getItemsStatus_args')
8722 
    if self.itemIds is not None:
8723 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
8724 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 8725 
      for iter36 in self.itemIds:
8726 
        oprot.writeI64(iter36)
7438 amit.gupta 8727 
      oprot.writeListEnd()
8728 
      oprot.writeFieldEnd()
8729 
    oprot.writeFieldStop()
8730 
    oprot.writeStructEnd()
8731 
 
8732 
  def validate(self):
8733 
    return
8734 
 
8735 
 
8736 
  def __repr__(self):
8737 
    L = ['%s=%r' % (key, value)
8738 
      for key, value in self.__dict__.iteritems()]
8739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8740 
 
8741 
  def __eq__(self, other):
8742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8743 
 
8744 
  def __ne__(self, other):
8745 
    return not (self == other)
8746 
 
8747 
class getItemsStatus_result:
8748 
  """
8749 
  Attributes:
8750 
   - success
8751 
   - isex
8752 
  """
8753 
 
8754 
  thrift_spec = (
8755 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
8756 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8757 
  )
8758 
 
8759 
  def __init__(self, success=None, isex=None,):
8760 
    self.success = success
8761 
    self.isex = isex
8762 
 
8763 
  def read(self, iprot):
8764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8766 
      return
8767 
    iprot.readStructBegin()
8768 
    while True:
8769 
      (fname, ftype, fid) = iprot.readFieldBegin()
8770 
      if ftype == TType.STOP:
8771 
        break
8772 
      if fid == 0:
8773 
        if ftype == TType.MAP:
8774 
          self.success = {}
8590 kshitij.so 8775 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
8776 
          for _i41 in xrange(_size37):
8777 
            _key42 = iprot.readI64();
8778 
            _val43 = iprot.readBool();
8779 
            self.success[_key42] = _val43
7438 amit.gupta 8780 
          iprot.readMapEnd()
8781 
        else:
8782 
          iprot.skip(ftype)
8783 
      elif fid == 1:
8784 
        if ftype == TType.STRUCT:
8785 
          self.isex = CatalogServiceException()
8786 
          self.isex.read(iprot)
8787 
        else:
8788 
          iprot.skip(ftype)
8789 
      else:
8790 
        iprot.skip(ftype)
8791 
      iprot.readFieldEnd()
8792 
    iprot.readStructEnd()
8793 
 
8794 
  def write(self, oprot):
8795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8797 
      return
8798 
    oprot.writeStructBegin('getItemsStatus_result')
8799 
    if self.success is not None:
8800 
      oprot.writeFieldBegin('success', TType.MAP, 0)
8801 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 8802 
      for kiter44,viter45 in self.success.items():
8803 
        oprot.writeI64(kiter44)
8804 
        oprot.writeBool(viter45)
7438 amit.gupta 8805 
      oprot.writeMapEnd()
8806 
      oprot.writeFieldEnd()
8807 
    if self.isex is not None:
8808 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8809 
      self.isex.write(oprot)
8810 
      oprot.writeFieldEnd()
8811 
    oprot.writeFieldStop()
8812 
    oprot.writeStructEnd()
8813 
 
8814 
  def validate(self):
8815 
    return
8816 
 
8817 
 
8818 
  def __repr__(self):
8819 
    L = ['%s=%r' % (key, value)
8820 
      for key, value in self.__dict__.iteritems()]
8821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8822 
 
8823 
  def __eq__(self, other):
8824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8825 
 
8826 
  def __ne__(self, other):
8827 
    return not (self == other)
8828 
 
5944 mandeep.dh 8829 
class getItemStatusDescription_args:
8830 
  """
8831 
  Attributes:
8832 
   - itemId
8833 
  """
8834 
 
8835 
  thrift_spec = (
8836 
    None, # 0
8837 
    (1, TType.I64, 'itemId', None, None, ), # 1
8838 
  )
8839 
 
8840 
  def __init__(self, itemId=None,):
8841 
    self.itemId = itemId
8842 
 
8843 
  def read(self, iprot):
8844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8846 
      return
8847 
    iprot.readStructBegin()
8848 
    while True:
8849 
      (fname, ftype, fid) = iprot.readFieldBegin()
8850 
      if ftype == TType.STOP:
8851 
        break
8852 
      if fid == 1:
8853 
        if ftype == TType.I64:
8854 
          self.itemId = iprot.readI64();
8855 
        else:
8856 
          iprot.skip(ftype)
8857 
      else:
8858 
        iprot.skip(ftype)
8859 
      iprot.readFieldEnd()
8860 
    iprot.readStructEnd()
8861 
 
8862 
  def write(self, oprot):
8863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8865 
      return
8866 
    oprot.writeStructBegin('getItemStatusDescription_args')
8867 
    if self.itemId is not None:
8868 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8869 
      oprot.writeI64(self.itemId)
8870 
      oprot.writeFieldEnd()
8871 
    oprot.writeFieldStop()
8872 
    oprot.writeStructEnd()
8873 
 
8874 
  def validate(self):
8875 
    return
8876 
 
8877 
 
8878 
  def __repr__(self):
8879 
    L = ['%s=%r' % (key, value)
8880 
      for key, value in self.__dict__.iteritems()]
8881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8882 
 
8883 
  def __eq__(self, other):
8884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8885 
 
8886 
  def __ne__(self, other):
8887 
    return not (self == other)
8888 
 
8889 
class getItemStatusDescription_result:
8890 
  """
8891 
  Attributes:
8892 
   - success
8893 
   - isex
8894 
  """
8895 
 
8896 
  thrift_spec = (
8897 
    (0, TType.STRING, 'success', None, None, ), # 0
8898 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8899 
  )
8900 
 
8901 
  def __init__(self, success=None, isex=None,):
8902 
    self.success = success
8903 
    self.isex = isex
8904 
 
8905 
  def read(self, iprot):
8906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8908 
      return
8909 
    iprot.readStructBegin()
8910 
    while True:
8911 
      (fname, ftype, fid) = iprot.readFieldBegin()
8912 
      if ftype == TType.STOP:
8913 
        break
8914 
      if fid == 0:
8915 
        if ftype == TType.STRING:
8916 
          self.success = iprot.readString();
8917 
        else:
8918 
          iprot.skip(ftype)
8919 
      elif fid == 1:
8920 
        if ftype == TType.STRUCT:
8921 
          self.isex = CatalogServiceException()
8922 
          self.isex.read(iprot)
8923 
        else:
8924 
          iprot.skip(ftype)
8925 
      else:
8926 
        iprot.skip(ftype)
8927 
      iprot.readFieldEnd()
8928 
    iprot.readStructEnd()
8929 
 
8930 
  def write(self, oprot):
8931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8933 
      return
8934 
    oprot.writeStructBegin('getItemStatusDescription_result')
8935 
    if self.success is not None:
8936 
      oprot.writeFieldBegin('success', TType.STRING, 0)
8937 
      oprot.writeString(self.success)
8938 
      oprot.writeFieldEnd()
8939 
    if self.isex is not None:
8940 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8941 
      self.isex.write(oprot)
8942 
      oprot.writeFieldEnd()
8943 
    oprot.writeFieldStop()
8944 
    oprot.writeStructEnd()
8945 
 
8946 
  def validate(self):
8947 
    return
8948 
 
8949 
 
8950 
  def __repr__(self):
8951 
    L = ['%s=%r' % (key, value)
8952 
      for key, value in self.__dict__.iteritems()]
8953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8954 
 
8955 
  def __eq__(self, other):
8956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8957 
 
8958 
  def __ne__(self, other):
8959 
    return not (self == other)
8960 
 
8961 
class startItemOn_args:
8962 
  """
8963 
  Attributes:
8964 
   - item_id
8965 
   - timestamp
8966 
  """
8967 
 
8968 
  thrift_spec = (
8969 
    None, # 0
8970 
    (1, TType.I64, 'item_id', None, None, ), # 1
8971 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8972 
  )
8973 
 
8974 
  def __init__(self, item_id=None, timestamp=None,):
8975 
    self.item_id = item_id
8976 
    self.timestamp = timestamp
8977 
 
8978 
  def read(self, iprot):
8979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8981 
      return
8982 
    iprot.readStructBegin()
8983 
    while True:
8984 
      (fname, ftype, fid) = iprot.readFieldBegin()
8985 
      if ftype == TType.STOP:
8986 
        break
8987 
      if fid == 1:
8988 
        if ftype == TType.I64:
8989 
          self.item_id = iprot.readI64();
8990 
        else:
8991 
          iprot.skip(ftype)
8992 
      elif fid == 2:
8993 
        if ftype == TType.I64:
8994 
          self.timestamp = iprot.readI64();
8995 
        else:
8996 
          iprot.skip(ftype)
8997 
      else:
8998 
        iprot.skip(ftype)
8999 
      iprot.readFieldEnd()
9000 
    iprot.readStructEnd()
9001 
 
9002 
  def write(self, oprot):
9003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9005 
      return
9006 
    oprot.writeStructBegin('startItemOn_args')
9007 
    if self.item_id is not None:
9008 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9009 
      oprot.writeI64(self.item_id)
9010 
      oprot.writeFieldEnd()
9011 
    if self.timestamp is not None:
9012 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
9013 
      oprot.writeI64(self.timestamp)
9014 
      oprot.writeFieldEnd()
9015 
    oprot.writeFieldStop()
9016 
    oprot.writeStructEnd()
9017 
 
9018 
  def validate(self):
9019 
    return
9020 
 
9021 
 
9022 
  def __repr__(self):
9023 
    L = ['%s=%r' % (key, value)
9024 
      for key, value in self.__dict__.iteritems()]
9025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9026 
 
9027 
  def __eq__(self, other):
9028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9029 
 
9030 
  def __ne__(self, other):
9031 
    return not (self == other)
9032 
 
9033 
class startItemOn_result:
9034 
  """
9035 
  Attributes:
9036 
   - cex
9037 
  """
9038 
 
9039 
  thrift_spec = (
9040 
    None, # 0
9041 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9042 
  )
9043 
 
9044 
  def __init__(self, cex=None,):
9045 
    self.cex = cex
9046 
 
9047 
  def read(self, iprot):
9048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9050 
      return
9051 
    iprot.readStructBegin()
9052 
    while True:
9053 
      (fname, ftype, fid) = iprot.readFieldBegin()
9054 
      if ftype == TType.STOP:
9055 
        break
9056 
      if fid == 1:
9057 
        if ftype == TType.STRUCT:
9058 
          self.cex = CatalogServiceException()
9059 
          self.cex.read(iprot)
9060 
        else:
9061 
          iprot.skip(ftype)
9062 
      else:
9063 
        iprot.skip(ftype)
9064 
      iprot.readFieldEnd()
9065 
    iprot.readStructEnd()
9066 
 
9067 
  def write(self, oprot):
9068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9070 
      return
9071 
    oprot.writeStructBegin('startItemOn_result')
9072 
    if self.cex is not None:
9073 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9074 
      self.cex.write(oprot)
9075 
      oprot.writeFieldEnd()
9076 
    oprot.writeFieldStop()
9077 
    oprot.writeStructEnd()
9078 
 
9079 
  def validate(self):
9080 
    return
9081 
 
9082 
 
9083 
  def __repr__(self):
9084 
    L = ['%s=%r' % (key, value)
9085 
      for key, value in self.__dict__.iteritems()]
9086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9087 
 
9088 
  def __eq__(self, other):
9089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9090 
 
9091 
  def __ne__(self, other):
9092 
    return not (self == other)
9093 
 
9094 
class retireItemOn_args:
9095 
  """
9096 
  Attributes:
9097 
   - item_id
9098 
   - timestamp
9099 
  """
9100 
 
9101 
  thrift_spec = (
9102 
    None, # 0
9103 
    (1, TType.I64, 'item_id', None, None, ), # 1
9104 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9105 
  )
9106 
 
9107 
  def __init__(self, item_id=None, timestamp=None,):
9108 
    self.item_id = item_id
9109 
    self.timestamp = timestamp
9110 
 
9111 
  def read(self, iprot):
9112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9114 
      return
9115 
    iprot.readStructBegin()
9116 
    while True:
9117 
      (fname, ftype, fid) = iprot.readFieldBegin()
9118 
      if ftype == TType.STOP:
9119 
        break
9120 
      if fid == 1:
9121 
        if ftype == TType.I64:
9122 
          self.item_id = iprot.readI64();
9123 
        else:
9124 
          iprot.skip(ftype)
9125 
      elif fid == 2:
9126 
        if ftype == TType.I64:
9127 
          self.timestamp = iprot.readI64();
9128 
        else:
9129 
          iprot.skip(ftype)
9130 
      else:
9131 
        iprot.skip(ftype)
9132 
      iprot.readFieldEnd()
9133 
    iprot.readStructEnd()
9134 
 
9135 
  def write(self, oprot):
9136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9138 
      return
9139 
    oprot.writeStructBegin('retireItemOn_args')
9140 
    if self.item_id is not None:
9141 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9142 
      oprot.writeI64(self.item_id)
9143 
      oprot.writeFieldEnd()
9144 
    if self.timestamp is not None:
9145 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
9146 
      oprot.writeI64(self.timestamp)
9147 
      oprot.writeFieldEnd()
9148 
    oprot.writeFieldStop()
9149 
    oprot.writeStructEnd()
9150 
 
9151 
  def validate(self):
9152 
    return
9153 
 
9154 
 
9155 
  def __repr__(self):
9156 
    L = ['%s=%r' % (key, value)
9157 
      for key, value in self.__dict__.iteritems()]
9158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9159 
 
9160 
  def __eq__(self, other):
9161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9162 
 
9163 
  def __ne__(self, other):
9164 
    return not (self == other)
9165 
 
9166 
class retireItemOn_result:
9167 
  """
9168 
  Attributes:
9169 
   - cex
9170 
  """
9171 
 
9172 
  thrift_spec = (
9173 
    None, # 0
9174 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9175 
  )
9176 
 
9177 
  def __init__(self, cex=None,):
9178 
    self.cex = cex
9179 
 
9180 
  def read(self, iprot):
9181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9183 
      return
9184 
    iprot.readStructBegin()
9185 
    while True:
9186 
      (fname, ftype, fid) = iprot.readFieldBegin()
9187 
      if ftype == TType.STOP:
9188 
        break
9189 
      if fid == 1:
9190 
        if ftype == TType.STRUCT:
9191 
          self.cex = CatalogServiceException()
9192 
          self.cex.read(iprot)
9193 
        else:
9194 
          iprot.skip(ftype)
9195 
      else:
9196 
        iprot.skip(ftype)
9197 
      iprot.readFieldEnd()
9198 
    iprot.readStructEnd()
9199 
 
9200 
  def write(self, oprot):
9201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9203 
      return
9204 
    oprot.writeStructBegin('retireItemOn_result')
9205 
    if self.cex is not None:
9206 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9207 
      self.cex.write(oprot)
9208 
      oprot.writeFieldEnd()
9209 
    oprot.writeFieldStop()
9210 
    oprot.writeStructEnd()
9211 
 
9212 
  def validate(self):
9213 
    return
9214 
 
9215 
 
9216 
  def __repr__(self):
9217 
    L = ['%s=%r' % (key, value)
9218 
      for key, value in self.__dict__.iteritems()]
9219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9220 
 
9221 
  def __eq__(self, other):
9222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9223 
 
9224 
  def __ne__(self, other):
9225 
    return not (self == other)
9226 
 
9227 
class changeItemStatus_args:
9228 
  """
9229 
  Attributes:
9230 
   - item_id
9231 
   - timestamp
9232 
   - newstatus
9233 
  """
9234 
 
9235 
  thrift_spec = (
9236 
    None, # 0
9237 
    (1, TType.I64, 'item_id', None, None, ), # 1
9238 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9239 
    (3, TType.I32, 'newstatus', None, None, ), # 3
9240 
  )
9241 
 
9242 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
9243 
    self.item_id = item_id
9244 
    self.timestamp = timestamp
9245 
    self.newstatus = newstatus
9246 
 
9247 
  def read(self, iprot):
9248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9250 
      return
9251 
    iprot.readStructBegin()
9252 
    while True:
9253 
      (fname, ftype, fid) = iprot.readFieldBegin()
9254 
      if ftype == TType.STOP:
9255 
        break
9256 
      if fid == 1:
9257 
        if ftype == TType.I64:
9258 
          self.item_id = iprot.readI64();
9259 
        else:
9260 
          iprot.skip(ftype)
9261 
      elif fid == 2:
9262 
        if ftype == TType.I64:
9263 
          self.timestamp = iprot.readI64();
9264 
        else:
9265 
          iprot.skip(ftype)
9266 
      elif fid == 3:
9267 
        if ftype == TType.I32:
9268 
          self.newstatus = iprot.readI32();
9269 
        else:
9270 
          iprot.skip(ftype)
9271 
      else:
9272 
        iprot.skip(ftype)
9273 
      iprot.readFieldEnd()
9274 
    iprot.readStructEnd()
9275 
 
9276 
  def write(self, oprot):
9277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9279 
      return
9280 
    oprot.writeStructBegin('changeItemStatus_args')
9281 
    if self.item_id is not None:
9282 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9283 
      oprot.writeI64(self.item_id)
9284 
      oprot.writeFieldEnd()
9285 
    if self.timestamp is not None:
9286 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
9287 
      oprot.writeI64(self.timestamp)
9288 
      oprot.writeFieldEnd()
9289 
    if self.newstatus is not None:
9290 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
9291 
      oprot.writeI32(self.newstatus)
9292 
      oprot.writeFieldEnd()
9293 
    oprot.writeFieldStop()
9294 
    oprot.writeStructEnd()
9295 
 
9296 
  def validate(self):
9297 
    return
9298 
 
9299 
 
9300 
  def __repr__(self):
9301 
    L = ['%s=%r' % (key, value)
9302 
      for key, value in self.__dict__.iteritems()]
9303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9304 
 
9305 
  def __eq__(self, other):
9306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9307 
 
9308 
  def __ne__(self, other):
9309 
    return not (self == other)
9310 
 
9311 
class changeItemStatus_result:
9312 
  """
9313 
  Attributes:
9314 
   - cex
9315 
  """
9316 
 
9317 
  thrift_spec = (
9318 
    None, # 0
9319 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9320 
  )
9321 
 
9322 
  def __init__(self, cex=None,):
9323 
    self.cex = cex
9324 
 
9325 
  def read(self, iprot):
9326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9328 
      return
9329 
    iprot.readStructBegin()
9330 
    while True:
9331 
      (fname, ftype, fid) = iprot.readFieldBegin()
9332 
      if ftype == TType.STOP:
9333 
        break
9334 
      if fid == 1:
9335 
        if ftype == TType.STRUCT:
9336 
          self.cex = CatalogServiceException()
9337 
          self.cex.read(iprot)
9338 
        else:
9339 
          iprot.skip(ftype)
9340 
      else:
9341 
        iprot.skip(ftype)
9342 
      iprot.readFieldEnd()
9343 
    iprot.readStructEnd()
9344 
 
9345 
  def write(self, oprot):
9346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9348 
      return
9349 
    oprot.writeStructBegin('changeItemStatus_result')
9350 
    if self.cex is not None:
9351 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9352 
      self.cex.write(oprot)
9353 
      oprot.writeFieldEnd()
9354 
    oprot.writeFieldStop()
9355 
    oprot.writeStructEnd()
9356 
 
9357 
  def validate(self):
9358 
    return
9359 
 
9360 
 
9361 
  def __repr__(self):
9362 
    L = ['%s=%r' % (key, value)
9363 
      for key, value in self.__dict__.iteritems()]
9364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9365 
 
9366 
  def __eq__(self, other):
9367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9368 
 
9369 
  def __ne__(self, other):
9370 
    return not (self == other)
9371 
 
9372 
class getItem_args:
9373 
  """
9374 
  Attributes:
9375 
   - item_id
9376 
  """
9377 
 
9378 
  thrift_spec = (
9379 
    None, # 0
9380 
    (1, TType.I64, 'item_id', None, None, ), # 1
9381 
  )
9382 
 
9383 
  def __init__(self, item_id=None,):
9384 
    self.item_id = item_id
9385 
 
9386 
  def read(self, iprot):
9387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9389 
      return
9390 
    iprot.readStructBegin()
9391 
    while True:
9392 
      (fname, ftype, fid) = iprot.readFieldBegin()
9393 
      if ftype == TType.STOP:
9394 
        break
9395 
      if fid == 1:
9396 
        if ftype == TType.I64:
9397 
          self.item_id = iprot.readI64();
9398 
        else:
9399 
          iprot.skip(ftype)
9400 
      else:
9401 
        iprot.skip(ftype)
9402 
      iprot.readFieldEnd()
9403 
    iprot.readStructEnd()
9404 
 
9405 
  def write(self, oprot):
9406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9408 
      return
9409 
    oprot.writeStructBegin('getItem_args')
9410 
    if self.item_id is not None:
9411 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9412 
      oprot.writeI64(self.item_id)
9413 
      oprot.writeFieldEnd()
9414 
    oprot.writeFieldStop()
9415 
    oprot.writeStructEnd()
9416 
 
9417 
  def validate(self):
9418 
    return
9419 
 
9420 
 
9421 
  def __repr__(self):
9422 
    L = ['%s=%r' % (key, value)
9423 
      for key, value in self.__dict__.iteritems()]
9424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9425 
 
9426 
  def __eq__(self, other):
9427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9428 
 
9429 
  def __ne__(self, other):
9430 
    return not (self == other)
9431 
 
9432 
class getItem_result:
9433 
  """
9434 
  Attributes:
9435 
   - success
9436 
   - cex
9437 
  """
9438 
 
9439 
  thrift_spec = (
9440 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9441 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9442 
  )
9443 
 
9444 
  def __init__(self, success=None, cex=None,):
9445 
    self.success = success
9446 
    self.cex = cex
9447 
 
9448 
  def read(self, iprot):
9449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9451 
      return
9452 
    iprot.readStructBegin()
9453 
    while True:
9454 
      (fname, ftype, fid) = iprot.readFieldBegin()
9455 
      if ftype == TType.STOP:
9456 
        break
9457 
      if fid == 0:
9458 
        if ftype == TType.STRUCT:
9459 
          self.success = Item()
9460 
          self.success.read(iprot)
9461 
        else:
9462 
          iprot.skip(ftype)
9463 
      elif fid == 1:
9464 
        if ftype == TType.STRUCT:
9465 
          self.cex = CatalogServiceException()
9466 
          self.cex.read(iprot)
9467 
        else:
9468 
          iprot.skip(ftype)
9469 
      else:
9470 
        iprot.skip(ftype)
9471 
      iprot.readFieldEnd()
9472 
    iprot.readStructEnd()
9473 
 
9474 
  def write(self, oprot):
9475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9477 
      return
9478 
    oprot.writeStructBegin('getItem_result')
9479 
    if self.success is not None:
9480 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9481 
      self.success.write(oprot)
9482 
      oprot.writeFieldEnd()
9483 
    if self.cex is not None:
9484 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9485 
      self.cex.write(oprot)
9486 
      oprot.writeFieldEnd()
9487 
    oprot.writeFieldStop()
9488 
    oprot.writeStructEnd()
9489 
 
9490 
  def validate(self):
9491 
    return
9492 
 
9493 
 
9494 
  def __repr__(self):
9495 
    L = ['%s=%r' % (key, value)
9496 
      for key, value in self.__dict__.iteritems()]
9497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9498 
 
9499 
  def __eq__(self, other):
9500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9501 
 
9502 
  def __ne__(self, other):
9503 
    return not (self == other)
9504 
 
9505 
class getItemsByCatalogId_args:
9506 
  """
9507 
  Attributes:
9508 
   - catalog_item_id
9509 
  """
9510 
 
9511 
  thrift_spec = (
9512 
    None, # 0
9513 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
9514 
  )
9515 
 
9516 
  def __init__(self, catalog_item_id=None,):
9517 
    self.catalog_item_id = catalog_item_id
9518 
 
9519 
  def read(self, iprot):
9520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9522 
      return
9523 
    iprot.readStructBegin()
9524 
    while True:
9525 
      (fname, ftype, fid) = iprot.readFieldBegin()
9526 
      if ftype == TType.STOP:
9527 
        break
9528 
      if fid == 1:
9529 
        if ftype == TType.I64:
9530 
          self.catalog_item_id = iprot.readI64();
9531 
        else:
9532 
          iprot.skip(ftype)
9533 
      else:
9534 
        iprot.skip(ftype)
9535 
      iprot.readFieldEnd()
9536 
    iprot.readStructEnd()
9537 
 
9538 
  def write(self, oprot):
9539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9541 
      return
9542 
    oprot.writeStructBegin('getItemsByCatalogId_args')
9543 
    if self.catalog_item_id is not None:
9544 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
9545 
      oprot.writeI64(self.catalog_item_id)
9546 
      oprot.writeFieldEnd()
9547 
    oprot.writeFieldStop()
9548 
    oprot.writeStructEnd()
9549 
 
9550 
  def validate(self):
9551 
    return
9552 
 
9553 
 
9554 
  def __repr__(self):
9555 
    L = ['%s=%r' % (key, value)
9556 
      for key, value in self.__dict__.iteritems()]
9557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9558 
 
9559 
  def __eq__(self, other):
9560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9561 
 
9562 
  def __ne__(self, other):
9563 
    return not (self == other)
9564 
 
9565 
class getItemsByCatalogId_result:
9566 
  """
9567 
  Attributes:
9568 
   - success
9569 
   - cex
9570 
  """
9571 
 
9572 
  thrift_spec = (
9573 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9574 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9575 
  )
9576 
 
9577 
  def __init__(self, success=None, cex=None,):
9578 
    self.success = success
9579 
    self.cex = cex
9580 
 
9581 
  def read(self, iprot):
9582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9584 
      return
9585 
    iprot.readStructBegin()
9586 
    while True:
9587 
      (fname, ftype, fid) = iprot.readFieldBegin()
9588 
      if ftype == TType.STOP:
9589 
        break
9590 
      if fid == 0:
9591 
        if ftype == TType.LIST:
9592 
          self.success = []
8590 kshitij.so 9593 
          (_etype49, _size46) = iprot.readListBegin()
9594 
          for _i50 in xrange(_size46):
9595 
            _elem51 = Item()
9596 
            _elem51.read(iprot)
9597 
            self.success.append(_elem51)
5944 mandeep.dh 9598 
          iprot.readListEnd()
9599 
        else:
9600 
          iprot.skip(ftype)
9601 
      elif fid == 1:
9602 
        if ftype == TType.STRUCT:
9603 
          self.cex = CatalogServiceException()
9604 
          self.cex.read(iprot)
9605 
        else:
9606 
          iprot.skip(ftype)
9607 
      else:
9608 
        iprot.skip(ftype)
9609 
      iprot.readFieldEnd()
9610 
    iprot.readStructEnd()
9611 
 
9612 
  def write(self, oprot):
9613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9615 
      return
9616 
    oprot.writeStructBegin('getItemsByCatalogId_result')
9617 
    if self.success is not None:
9618 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9619 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9620 
      for iter52 in self.success:
9621 
        iter52.write(oprot)
5944 mandeep.dh 9622 
      oprot.writeListEnd()
9623 
      oprot.writeFieldEnd()
9624 
    if self.cex is not None:
9625 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9626 
      self.cex.write(oprot)
9627 
      oprot.writeFieldEnd()
9628 
    oprot.writeFieldStop()
9629 
    oprot.writeStructEnd()
9630 
 
9631 
  def validate(self):
9632 
    return
9633 
 
9634 
 
9635 
  def __repr__(self):
9636 
    L = ['%s=%r' % (key, value)
9637 
      for key, value in self.__dict__.iteritems()]
9638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9639 
 
9640 
  def __eq__(self, other):
9641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9642 
 
9643 
  def __ne__(self, other):
9644 
    return not (self == other)
9645 
 
9646 
class getValidItemsByCatalogId_args:
9647 
  """
9648 
  Attributes:
9649 
   - catalog_item_id
9650 
  """
9651 
 
9652 
  thrift_spec = (
9653 
    None, # 0
9654 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
9655 
  )
9656 
 
9657 
  def __init__(self, catalog_item_id=None,):
9658 
    self.catalog_item_id = catalog_item_id
9659 
 
9660 
  def read(self, iprot):
9661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9663 
      return
9664 
    iprot.readStructBegin()
9665 
    while True:
9666 
      (fname, ftype, fid) = iprot.readFieldBegin()
9667 
      if ftype == TType.STOP:
9668 
        break
9669 
      if fid == 1:
9670 
        if ftype == TType.I64:
9671 
          self.catalog_item_id = iprot.readI64();
9672 
        else:
9673 
          iprot.skip(ftype)
9674 
      else:
9675 
        iprot.skip(ftype)
9676 
      iprot.readFieldEnd()
9677 
    iprot.readStructEnd()
9678 
 
9679 
  def write(self, oprot):
9680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9682 
      return
9683 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
9684 
    if self.catalog_item_id is not None:
9685 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
9686 
      oprot.writeI64(self.catalog_item_id)
9687 
      oprot.writeFieldEnd()
9688 
    oprot.writeFieldStop()
9689 
    oprot.writeStructEnd()
9690 
 
9691 
  def validate(self):
9692 
    return
9693 
 
9694 
 
9695 
  def __repr__(self):
9696 
    L = ['%s=%r' % (key, value)
9697 
      for key, value in self.__dict__.iteritems()]
9698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9699 
 
9700 
  def __eq__(self, other):
9701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9702 
 
9703 
  def __ne__(self, other):
9704 
    return not (self == other)
9705 
 
9706 
class getValidItemsByCatalogId_result:
9707 
  """
9708 
  Attributes:
9709 
   - success
9710 
   - cex
9711 
  """
9712 
 
9713 
  thrift_spec = (
9714 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9715 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9716 
  )
9717 
 
9718 
  def __init__(self, success=None, cex=None,):
9719 
    self.success = success
9720 
    self.cex = cex
9721 
 
9722 
  def read(self, iprot):
9723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9725 
      return
9726 
    iprot.readStructBegin()
9727 
    while True:
9728 
      (fname, ftype, fid) = iprot.readFieldBegin()
9729 
      if ftype == TType.STOP:
9730 
        break
9731 
      if fid == 0:
9732 
        if ftype == TType.LIST:
9733 
          self.success = []
8590 kshitij.so 9734 
          (_etype56, _size53) = iprot.readListBegin()
9735 
          for _i57 in xrange(_size53):
9736 
            _elem58 = Item()
9737 
            _elem58.read(iprot)
9738 
            self.success.append(_elem58)
5944 mandeep.dh 9739 
          iprot.readListEnd()
9740 
        else:
9741 
          iprot.skip(ftype)
9742 
      elif fid == 1:
9743 
        if ftype == TType.STRUCT:
9744 
          self.cex = CatalogServiceException()
9745 
          self.cex.read(iprot)
9746 
        else:
9747 
          iprot.skip(ftype)
9748 
      else:
9749 
        iprot.skip(ftype)
9750 
      iprot.readFieldEnd()
9751 
    iprot.readStructEnd()
9752 
 
9753 
  def write(self, oprot):
9754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9756 
      return
9757 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
9758 
    if self.success is not None:
9759 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9760 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9761 
      for iter59 in self.success:
9762 
        iter59.write(oprot)
5944 mandeep.dh 9763 
      oprot.writeListEnd()
9764 
      oprot.writeFieldEnd()
9765 
    if self.cex is not None:
9766 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9767 
      self.cex.write(oprot)
9768 
      oprot.writeFieldEnd()
9769 
    oprot.writeFieldStop()
9770 
    oprot.writeStructEnd()
9771 
 
9772 
  def validate(self):
9773 
    return
9774 
 
9775 
 
9776 
  def __repr__(self):
9777 
    L = ['%s=%r' % (key, value)
9778 
      for key, value in self.__dict__.iteritems()]
9779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9780 
 
9781 
  def __eq__(self, other):
9782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9783 
 
9784 
  def __ne__(self, other):
9785 
    return not (self == other)
9786 
 
9787 
class getAllItems_args:
9788 
  """
9789 
  Attributes:
9790 
   - isActive
9791 
  """
9792 
 
9793 
  thrift_spec = (
9794 
    None, # 0
9795 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
9796 
  )
9797 
 
9798 
  def __init__(self, isActive=None,):
9799 
    self.isActive = isActive
9800 
 
9801 
  def read(self, iprot):
9802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9804 
      return
9805 
    iprot.readStructBegin()
9806 
    while True:
9807 
      (fname, ftype, fid) = iprot.readFieldBegin()
9808 
      if ftype == TType.STOP:
9809 
        break
9810 
      if fid == 1:
9811 
        if ftype == TType.BOOL:
9812 
          self.isActive = iprot.readBool();
9813 
        else:
9814 
          iprot.skip(ftype)
9815 
      else:
9816 
        iprot.skip(ftype)
9817 
      iprot.readFieldEnd()
9818 
    iprot.readStructEnd()
9819 
 
9820 
  def write(self, oprot):
9821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9823 
      return
9824 
    oprot.writeStructBegin('getAllItems_args')
9825 
    if self.isActive is not None:
9826 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
9827 
      oprot.writeBool(self.isActive)
9828 
      oprot.writeFieldEnd()
9829 
    oprot.writeFieldStop()
9830 
    oprot.writeStructEnd()
9831 
 
9832 
  def validate(self):
9833 
    return
9834 
 
9835 
 
9836 
  def __repr__(self):
9837 
    L = ['%s=%r' % (key, value)
9838 
      for key, value in self.__dict__.iteritems()]
9839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9840 
 
9841 
  def __eq__(self, other):
9842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9843 
 
9844 
  def __ne__(self, other):
9845 
    return not (self == other)
9846 
 
9847 
class getAllItems_result:
9848 
  """
9849 
  Attributes:
9850 
   - success
9851 
   - cex
9852 
  """
9853 
 
9854 
  thrift_spec = (
9855 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9856 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9857 
  )
9858 
 
9859 
  def __init__(self, success=None, cex=None,):
9860 
    self.success = success
9861 
    self.cex = cex
9862 
 
9863 
  def read(self, iprot):
9864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9866 
      return
9867 
    iprot.readStructBegin()
9868 
    while True:
9869 
      (fname, ftype, fid) = iprot.readFieldBegin()
9870 
      if ftype == TType.STOP:
9871 
        break
9872 
      if fid == 0:
9873 
        if ftype == TType.LIST:
9874 
          self.success = []
8590 kshitij.so 9875 
          (_etype63, _size60) = iprot.readListBegin()
9876 
          for _i64 in xrange(_size60):
9877 
            _elem65 = Item()
9878 
            _elem65.read(iprot)
9879 
            self.success.append(_elem65)
5944 mandeep.dh 9880 
          iprot.readListEnd()
9881 
        else:
9882 
          iprot.skip(ftype)
9883 
      elif fid == 1:
9884 
        if ftype == TType.STRUCT:
9885 
          self.cex = CatalogServiceException()
9886 
          self.cex.read(iprot)
9887 
        else:
9888 
          iprot.skip(ftype)
9889 
      else:
9890 
        iprot.skip(ftype)
9891 
      iprot.readFieldEnd()
9892 
    iprot.readStructEnd()
9893 
 
9894 
  def write(self, oprot):
9895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9897 
      return
9898 
    oprot.writeStructBegin('getAllItems_result')
9899 
    if self.success is not None:
9900 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9901 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9902 
      for iter66 in self.success:
9903 
        iter66.write(oprot)
5944 mandeep.dh 9904 
      oprot.writeListEnd()
9905 
      oprot.writeFieldEnd()
9906 
    if self.cex is not None:
9907 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9908 
      self.cex.write(oprot)
9909 
      oprot.writeFieldEnd()
9910 
    oprot.writeFieldStop()
9911 
    oprot.writeStructEnd()
9912 
 
9913 
  def validate(self):
9914 
    return
9915 
 
9916 
 
9917 
  def __repr__(self):
9918 
    L = ['%s=%r' % (key, value)
9919 
      for key, value in self.__dict__.iteritems()]
9920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9921 
 
9922 
  def __eq__(self, other):
9923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9924 
 
9925 
  def __ne__(self, other):
9926 
    return not (self == other)
9927 
 
9928 
class getAllItemsByStatus_args:
9929 
  """
9930 
  Attributes:
9931 
   - itemStatus
9932 
  """
9933 
 
9934 
  thrift_spec = (
9935 
    None, # 0
9936 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9937 
  )
9938 
 
9939 
  def __init__(self, itemStatus=None,):
9940 
    self.itemStatus = itemStatus
9941 
 
9942 
  def read(self, iprot):
9943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9945 
      return
9946 
    iprot.readStructBegin()
9947 
    while True:
9948 
      (fname, ftype, fid) = iprot.readFieldBegin()
9949 
      if ftype == TType.STOP:
9950 
        break
9951 
      if fid == 1:
9952 
        if ftype == TType.I32:
9953 
          self.itemStatus = iprot.readI32();
9954 
        else:
9955 
          iprot.skip(ftype)
9956 
      else:
9957 
        iprot.skip(ftype)
9958 
      iprot.readFieldEnd()
9959 
    iprot.readStructEnd()
9960 
 
9961 
  def write(self, oprot):
9962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9964 
      return
9965 
    oprot.writeStructBegin('getAllItemsByStatus_args')
9966 
    if self.itemStatus is not None:
9967 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9968 
      oprot.writeI32(self.itemStatus)
9969 
      oprot.writeFieldEnd()
9970 
    oprot.writeFieldStop()
9971 
    oprot.writeStructEnd()
9972 
 
9973 
  def validate(self):
9974 
    return
9975 
 
9976 
 
9977 
  def __repr__(self):
9978 
    L = ['%s=%r' % (key, value)
9979 
      for key, value in self.__dict__.iteritems()]
9980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9981 
 
9982 
  def __eq__(self, other):
9983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9984 
 
9985 
  def __ne__(self, other):
9986 
    return not (self == other)
9987 
 
9988 
class getAllItemsByStatus_result:
9989 
  """
9990 
  Attributes:
9991 
   - success
9992 
   - cex
9993 
  """
9994 
 
9995 
  thrift_spec = (
9996 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9997 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9998 
  )
9999 
 
10000 
  def __init__(self, success=None, cex=None,):
10001 
    self.success = success
10002 
    self.cex = cex
10003 
 
10004 
  def read(self, iprot):
10005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10007 
      return
10008 
    iprot.readStructBegin()
10009 
    while True:
10010 
      (fname, ftype, fid) = iprot.readFieldBegin()
10011 
      if ftype == TType.STOP:
10012 
        break
10013 
      if fid == 0:
10014 
        if ftype == TType.LIST:
10015 
          self.success = []
8590 kshitij.so 10016 
          (_etype70, _size67) = iprot.readListBegin()
10017 
          for _i71 in xrange(_size67):
10018 
            _elem72 = Item()
10019 
            _elem72.read(iprot)
10020 
            self.success.append(_elem72)
5944 mandeep.dh 10021 
          iprot.readListEnd()
10022 
        else:
10023 
          iprot.skip(ftype)
10024 
      elif fid == 1:
10025 
        if ftype == TType.STRUCT:
10026 
          self.cex = CatalogServiceException()
10027 
          self.cex.read(iprot)
10028 
        else:
10029 
          iprot.skip(ftype)
10030 
      else:
10031 
        iprot.skip(ftype)
10032 
      iprot.readFieldEnd()
10033 
    iprot.readStructEnd()
10034 
 
10035 
  def write(self, oprot):
10036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10038 
      return
10039 
    oprot.writeStructBegin('getAllItemsByStatus_result')
10040 
    if self.success is not None:
10041 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10042 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10043 
      for iter73 in self.success:
10044 
        iter73.write(oprot)
5944 mandeep.dh 10045 
      oprot.writeListEnd()
10046 
      oprot.writeFieldEnd()
10047 
    if self.cex is not None:
10048 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10049 
      self.cex.write(oprot)
10050 
      oprot.writeFieldEnd()
10051 
    oprot.writeFieldStop()
10052 
    oprot.writeStructEnd()
10053 
 
10054 
  def validate(self):
10055 
    return
10056 
 
10057 
 
10058 
  def __repr__(self):
10059 
    L = ['%s=%r' % (key, value)
10060 
      for key, value in self.__dict__.iteritems()]
10061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10062 
 
10063 
  def __eq__(self, other):
10064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10065 
 
10066 
  def __ne__(self, other):
10067 
    return not (self == other)
10068 
 
10069 
class markItemAsContentComplete_args:
10070 
  """
10071 
  Attributes:
10072 
   - entityId
10073 
   - category
10074 
   - brand
10075 
   - modelName
10076 
   - modelNumber
9253 rajveer 10077 
   - isAndroid
5944 mandeep.dh 10078 
  """
10079 
 
10080 
  thrift_spec = (
10081 
    None, # 0
10082 
    (1, TType.I64, 'entityId', None, None, ), # 1
10083 
    (2, TType.I64, 'category', None, None, ), # 2
10084 
    (3, TType.STRING, 'brand', None, None, ), # 3
10085 
    (4, TType.STRING, 'modelName', None, None, ), # 4
10086 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 10087 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 10088 
  )
10089 
 
9253 rajveer 10090 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 10091 
    self.entityId = entityId
10092 
    self.category = category
10093 
    self.brand = brand
10094 
    self.modelName = modelName
10095 
    self.modelNumber = modelNumber
9253 rajveer 10096 
    self.isAndroid = isAndroid
5944 mandeep.dh 10097 
 
10098 
  def read(self, iprot):
10099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10101 
      return
10102 
    iprot.readStructBegin()
10103 
    while True:
10104 
      (fname, ftype, fid) = iprot.readFieldBegin()
10105 
      if ftype == TType.STOP:
10106 
        break
10107 
      if fid == 1:
10108 
        if ftype == TType.I64:
10109 
          self.entityId = iprot.readI64();
10110 
        else:
10111 
          iprot.skip(ftype)
10112 
      elif fid == 2:
10113 
        if ftype == TType.I64:
10114 
          self.category = iprot.readI64();
10115 
        else:
10116 
          iprot.skip(ftype)
10117 
      elif fid == 3:
10118 
        if ftype == TType.STRING:
10119 
          self.brand = iprot.readString();
10120 
        else:
10121 
          iprot.skip(ftype)
10122 
      elif fid == 4:
10123 
        if ftype == TType.STRING:
10124 
          self.modelName = iprot.readString();
10125 
        else:
10126 
          iprot.skip(ftype)
10127 
      elif fid == 5:
10128 
        if ftype == TType.STRING:
10129 
          self.modelNumber = iprot.readString();
10130 
        else:
10131 
          iprot.skip(ftype)
9253 rajveer 10132 
      elif fid == 6:
10133 
        if ftype == TType.BOOL:
10134 
          self.isAndroid = iprot.readBool();
10135 
        else:
10136 
          iprot.skip(ftype)
5944 mandeep.dh 10137 
      else:
10138 
        iprot.skip(ftype)
10139 
      iprot.readFieldEnd()
10140 
    iprot.readStructEnd()
10141 
 
10142 
  def write(self, oprot):
10143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10145 
      return
10146 
    oprot.writeStructBegin('markItemAsContentComplete_args')
10147 
    if self.entityId is not None:
10148 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
10149 
      oprot.writeI64(self.entityId)
10150 
      oprot.writeFieldEnd()
10151 
    if self.category is not None:
10152 
      oprot.writeFieldBegin('category', TType.I64, 2)
10153 
      oprot.writeI64(self.category)
10154 
      oprot.writeFieldEnd()
10155 
    if self.brand is not None:
10156 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10157 
      oprot.writeString(self.brand)
10158 
      oprot.writeFieldEnd()
10159 
    if self.modelName is not None:
10160 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
10161 
      oprot.writeString(self.modelName)
10162 
      oprot.writeFieldEnd()
10163 
    if self.modelNumber is not None:
10164 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
10165 
      oprot.writeString(self.modelNumber)
10166 
      oprot.writeFieldEnd()
9253 rajveer 10167 
    if self.isAndroid is not None:
10168 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
10169 
      oprot.writeBool(self.isAndroid)
10170 
      oprot.writeFieldEnd()
5944 mandeep.dh 10171 
    oprot.writeFieldStop()
10172 
    oprot.writeStructEnd()
10173 
 
10174 
  def validate(self):
10175 
    return
10176 
 
10177 
 
10178 
  def __repr__(self):
10179 
    L = ['%s=%r' % (key, value)
10180 
      for key, value in self.__dict__.iteritems()]
10181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10182 
 
10183 
  def __eq__(self, other):
10184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10185 
 
10186 
  def __ne__(self, other):
10187 
    return not (self == other)
10188 
 
10189 
class markItemAsContentComplete_result:
10190 
  """
10191 
  Attributes:
10192 
   - success
10193 
   - cex
10194 
  """
10195 
 
10196 
  thrift_spec = (
10197 
    (0, TType.BOOL, 'success', None, None, ), # 0
10198 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10199 
  )
10200 
 
10201 
  def __init__(self, success=None, cex=None,):
10202 
    self.success = success
10203 
    self.cex = cex
10204 
 
10205 
  def read(self, iprot):
10206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10208 
      return
10209 
    iprot.readStructBegin()
10210 
    while True:
10211 
      (fname, ftype, fid) = iprot.readFieldBegin()
10212 
      if ftype == TType.STOP:
10213 
        break
10214 
      if fid == 0:
10215 
        if ftype == TType.BOOL:
10216 
          self.success = iprot.readBool();
10217 
        else:
10218 
          iprot.skip(ftype)
10219 
      elif fid == 1:
10220 
        if ftype == TType.STRUCT:
10221 
          self.cex = CatalogServiceException()
10222 
          self.cex.read(iprot)
10223 
        else:
10224 
          iprot.skip(ftype)
10225 
      else:
10226 
        iprot.skip(ftype)
10227 
      iprot.readFieldEnd()
10228 
    iprot.readStructEnd()
10229 
 
10230 
  def write(self, oprot):
10231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10233 
      return
10234 
    oprot.writeStructBegin('markItemAsContentComplete_result')
10235 
    if self.success is not None:
10236 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10237 
      oprot.writeBool(self.success)
10238 
      oprot.writeFieldEnd()
10239 
    if self.cex is not None:
10240 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10241 
      self.cex.write(oprot)
10242 
      oprot.writeFieldEnd()
10243 
    oprot.writeFieldStop()
10244 
    oprot.writeStructEnd()
10245 
 
10246 
  def validate(self):
10247 
    return
10248 
 
10249 
 
10250 
  def __repr__(self):
10251 
    L = ['%s=%r' % (key, value)
10252 
      for key, value in self.__dict__.iteritems()]
10253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10254 
 
10255 
  def __eq__(self, other):
10256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10257 
 
10258 
  def __ne__(self, other):
10259 
    return not (self == other)
10260 
 
10261 
class getAllItemsInRange_args:
10262 
  """
10263 
  Attributes:
10264 
   - offset
10265 
   - limit
10266 
  """
10267 
 
10268 
  thrift_spec = (
10269 
    None, # 0
10270 
    (1, TType.I64, 'offset', None, None, ), # 1
10271 
    (2, TType.I64, 'limit', None, None, ), # 2
10272 
  )
10273 
 
10274 
  def __init__(self, offset=None, limit=None,):
10275 
    self.offset = offset
10276 
    self.limit = limit
10277 
 
10278 
  def read(self, iprot):
10279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10281 
      return
10282 
    iprot.readStructBegin()
10283 
    while True:
10284 
      (fname, ftype, fid) = iprot.readFieldBegin()
10285 
      if ftype == TType.STOP:
10286 
        break
10287 
      if fid == 1:
10288 
        if ftype == TType.I64:
10289 
          self.offset = iprot.readI64();
10290 
        else:
10291 
          iprot.skip(ftype)
10292 
      elif fid == 2:
10293 
        if ftype == TType.I64:
10294 
          self.limit = iprot.readI64();
10295 
        else:
10296 
          iprot.skip(ftype)
10297 
      else:
10298 
        iprot.skip(ftype)
10299 
      iprot.readFieldEnd()
10300 
    iprot.readStructEnd()
10301 
 
10302 
  def write(self, oprot):
10303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10305 
      return
10306 
    oprot.writeStructBegin('getAllItemsInRange_args')
10307 
    if self.offset is not None:
10308 
      oprot.writeFieldBegin('offset', TType.I64, 1)
10309 
      oprot.writeI64(self.offset)
10310 
      oprot.writeFieldEnd()
10311 
    if self.limit is not None:
10312 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10313 
      oprot.writeI64(self.limit)
10314 
      oprot.writeFieldEnd()
10315 
    oprot.writeFieldStop()
10316 
    oprot.writeStructEnd()
10317 
 
10318 
  def validate(self):
10319 
    return
10320 
 
10321 
 
10322 
  def __repr__(self):
10323 
    L = ['%s=%r' % (key, value)
10324 
      for key, value in self.__dict__.iteritems()]
10325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10326 
 
10327 
  def __eq__(self, other):
10328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10329 
 
10330 
  def __ne__(self, other):
10331 
    return not (self == other)
10332 
 
10333 
class getAllItemsInRange_result:
10334 
  """
10335 
  Attributes:
10336 
   - success
10337 
   - cex
10338 
  """
10339 
 
10340 
  thrift_spec = (
10341 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10342 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10343 
  )
10344 
 
10345 
  def __init__(self, success=None, cex=None,):
10346 
    self.success = success
10347 
    self.cex = cex
10348 
 
10349 
  def read(self, iprot):
10350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10352 
      return
10353 
    iprot.readStructBegin()
10354 
    while True:
10355 
      (fname, ftype, fid) = iprot.readFieldBegin()
10356 
      if ftype == TType.STOP:
10357 
        break
10358 
      if fid == 0:
10359 
        if ftype == TType.LIST:
10360 
          self.success = []
8590 kshitij.so 10361 
          (_etype77, _size74) = iprot.readListBegin()
10362 
          for _i78 in xrange(_size74):
10363 
            _elem79 = Item()
10364 
            _elem79.read(iprot)
10365 
            self.success.append(_elem79)
5944 mandeep.dh 10366 
          iprot.readListEnd()
10367 
        else:
10368 
          iprot.skip(ftype)
10369 
      elif fid == 1:
10370 
        if ftype == TType.STRUCT:
10371 
          self.cex = CatalogServiceException()
10372 
          self.cex.read(iprot)
10373 
        else:
10374 
          iprot.skip(ftype)
10375 
      else:
10376 
        iprot.skip(ftype)
10377 
      iprot.readFieldEnd()
10378 
    iprot.readStructEnd()
10379 
 
10380 
  def write(self, oprot):
10381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10383 
      return
10384 
    oprot.writeStructBegin('getAllItemsInRange_result')
10385 
    if self.success is not None:
10386 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10387 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10388 
      for iter80 in self.success:
10389 
        iter80.write(oprot)
5944 mandeep.dh 10390 
      oprot.writeListEnd()
10391 
      oprot.writeFieldEnd()
10392 
    if self.cex is not None:
10393 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10394 
      self.cex.write(oprot)
10395 
      oprot.writeFieldEnd()
10396 
    oprot.writeFieldStop()
10397 
    oprot.writeStructEnd()
10398 
 
10399 
  def validate(self):
10400 
    return
10401 
 
10402 
 
10403 
  def __repr__(self):
10404 
    L = ['%s=%r' % (key, value)
10405 
      for key, value in self.__dict__.iteritems()]
10406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10407 
 
10408 
  def __eq__(self, other):
10409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10410 
 
10411 
  def __ne__(self, other):
10412 
    return not (self == other)
10413 
 
10414 
class getAllItemsByStatusInRange_args:
10415 
  """
10416 
  Attributes:
10417 
   - itemStatus
10418 
   - offset
10419 
   - limit
10420 
  """
10421 
 
10422 
  thrift_spec = (
10423 
    None, # 0
10424 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
10425 
    (2, TType.I64, 'offset', None, None, ), # 2
10426 
    (3, TType.I64, 'limit', None, None, ), # 3
10427 
  )
10428 
 
10429 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
10430 
    self.itemStatus = itemStatus
10431 
    self.offset = offset
10432 
    self.limit = limit
10433 
 
10434 
  def read(self, iprot):
10435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10437 
      return
10438 
    iprot.readStructBegin()
10439 
    while True:
10440 
      (fname, ftype, fid) = iprot.readFieldBegin()
10441 
      if ftype == TType.STOP:
10442 
        break
10443 
      if fid == 1:
10444 
        if ftype == TType.I32:
10445 
          self.itemStatus = iprot.readI32();
10446 
        else:
10447 
          iprot.skip(ftype)
10448 
      elif fid == 2:
10449 
        if ftype == TType.I64:
10450 
          self.offset = iprot.readI64();
10451 
        else:
10452 
          iprot.skip(ftype)
10453 
      elif fid == 3:
10454 
        if ftype == TType.I64:
10455 
          self.limit = iprot.readI64();
10456 
        else:
10457 
          iprot.skip(ftype)
10458 
      else:
10459 
        iprot.skip(ftype)
10460 
      iprot.readFieldEnd()
10461 
    iprot.readStructEnd()
10462 
 
10463 
  def write(self, oprot):
10464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10466 
      return
10467 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
10468 
    if self.itemStatus is not None:
10469 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
10470 
      oprot.writeI32(self.itemStatus)
10471 
      oprot.writeFieldEnd()
10472 
    if self.offset is not None:
10473 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10474 
      oprot.writeI64(self.offset)
10475 
      oprot.writeFieldEnd()
10476 
    if self.limit is not None:
10477 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10478 
      oprot.writeI64(self.limit)
10479 
      oprot.writeFieldEnd()
10480 
    oprot.writeFieldStop()
10481 
    oprot.writeStructEnd()
10482 
 
10483 
  def validate(self):
10484 
    return
10485 
 
10486 
 
10487 
  def __repr__(self):
10488 
    L = ['%s=%r' % (key, value)
10489 
      for key, value in self.__dict__.iteritems()]
10490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10491 
 
10492 
  def __eq__(self, other):
10493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10494 
 
10495 
  def __ne__(self, other):
10496 
    return not (self == other)
10497 
 
10498 
class getAllItemsByStatusInRange_result:
10499 
  """
10500 
  Attributes:
10501 
   - success
10502 
   - cex
10503 
  """
10504 
 
10505 
  thrift_spec = (
10506 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10507 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10508 
  )
10509 
 
10510 
  def __init__(self, success=None, cex=None,):
10511 
    self.success = success
10512 
    self.cex = cex
10513 
 
10514 
  def read(self, iprot):
10515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10517 
      return
10518 
    iprot.readStructBegin()
10519 
    while True:
10520 
      (fname, ftype, fid) = iprot.readFieldBegin()
10521 
      if ftype == TType.STOP:
10522 
        break
10523 
      if fid == 0:
10524 
        if ftype == TType.LIST:
10525 
          self.success = []
8590 kshitij.so 10526 
          (_etype84, _size81) = iprot.readListBegin()
10527 
          for _i85 in xrange(_size81):
10528 
            _elem86 = Item()
10529 
            _elem86.read(iprot)
10530 
            self.success.append(_elem86)
5944 mandeep.dh 10531 
          iprot.readListEnd()
10532 
        else:
10533 
          iprot.skip(ftype)
10534 
      elif fid == 1:
10535 
        if ftype == TType.STRUCT:
10536 
          self.cex = CatalogServiceException()
10537 
          self.cex.read(iprot)
10538 
        else:
10539 
          iprot.skip(ftype)
10540 
      else:
10541 
        iprot.skip(ftype)
10542 
      iprot.readFieldEnd()
10543 
    iprot.readStructEnd()
10544 
 
10545 
  def write(self, oprot):
10546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10548 
      return
10549 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
10550 
    if self.success is not None:
10551 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10552 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10553 
      for iter87 in self.success:
10554 
        iter87.write(oprot)
5944 mandeep.dh 10555 
      oprot.writeListEnd()
10556 
      oprot.writeFieldEnd()
10557 
    if self.cex is not None:
10558 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10559 
      self.cex.write(oprot)
10560 
      oprot.writeFieldEnd()
10561 
    oprot.writeFieldStop()
10562 
    oprot.writeStructEnd()
10563 
 
10564 
  def validate(self):
10565 
    return
10566 
 
10567 
 
10568 
  def __repr__(self):
10569 
    L = ['%s=%r' % (key, value)
10570 
      for key, value in self.__dict__.iteritems()]
10571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10572 
 
10573 
  def __eq__(self, other):
10574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10575 
 
10576 
  def __ne__(self, other):
10577 
    return not (self == other)
10578 
 
10579 
class getItemCountByStatus_args:
10580 
  """
10581 
  Attributes:
10582 
   - useStatus
10583 
   - itemStatus
10584 
  """
10585 
 
10586 
  thrift_spec = (
10587 
    None, # 0
10588 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
10589 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
10590 
  )
10591 
 
10592 
  def __init__(self, useStatus=None, itemStatus=None,):
10593 
    self.useStatus = useStatus
10594 
    self.itemStatus = itemStatus
10595 
 
10596 
  def read(self, iprot):
10597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10599 
      return
10600 
    iprot.readStructBegin()
10601 
    while True:
10602 
      (fname, ftype, fid) = iprot.readFieldBegin()
10603 
      if ftype == TType.STOP:
10604 
        break
10605 
      if fid == 1:
10606 
        if ftype == TType.BOOL:
10607 
          self.useStatus = iprot.readBool();
10608 
        else:
10609 
          iprot.skip(ftype)
10610 
      elif fid == 2:
10611 
        if ftype == TType.I32:
10612 
          self.itemStatus = iprot.readI32();
10613 
        else:
10614 
          iprot.skip(ftype)
10615 
      else:
10616 
        iprot.skip(ftype)
10617 
      iprot.readFieldEnd()
10618 
    iprot.readStructEnd()
10619 
 
10620 
  def write(self, oprot):
10621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10623 
      return
10624 
    oprot.writeStructBegin('getItemCountByStatus_args')
10625 
    if self.useStatus is not None:
10626 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
10627 
      oprot.writeBool(self.useStatus)
10628 
      oprot.writeFieldEnd()
10629 
    if self.itemStatus is not None:
10630 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
10631 
      oprot.writeI32(self.itemStatus)
10632 
      oprot.writeFieldEnd()
10633 
    oprot.writeFieldStop()
10634 
    oprot.writeStructEnd()
10635 
 
10636 
  def validate(self):
10637 
    return
10638 
 
10639 
 
10640 
  def __repr__(self):
10641 
    L = ['%s=%r' % (key, value)
10642 
      for key, value in self.__dict__.iteritems()]
10643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10644 
 
10645 
  def __eq__(self, other):
10646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10647 
 
10648 
  def __ne__(self, other):
10649 
    return not (self == other)
10650 
 
10651 
class getItemCountByStatus_result:
10652 
  """
10653 
  Attributes:
10654 
   - success
10655 
  """
10656 
 
10657 
  thrift_spec = (
10658 
    (0, TType.I32, 'success', None, None, ), # 0
10659 
  )
10660 
 
10661 
  def __init__(self, success=None,):
10662 
    self.success = success
10663 
 
10664 
  def read(self, iprot):
10665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10667 
      return
10668 
    iprot.readStructBegin()
10669 
    while True:
10670 
      (fname, ftype, fid) = iprot.readFieldBegin()
10671 
      if ftype == TType.STOP:
10672 
        break
10673 
      if fid == 0:
10674 
        if ftype == TType.I32:
10675 
          self.success = iprot.readI32();
10676 
        else:
10677 
          iprot.skip(ftype)
10678 
      else:
10679 
        iprot.skip(ftype)
10680 
      iprot.readFieldEnd()
10681 
    iprot.readStructEnd()
10682 
 
10683 
  def write(self, oprot):
10684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10686 
      return
10687 
    oprot.writeStructBegin('getItemCountByStatus_result')
10688 
    if self.success is not None:
10689 
      oprot.writeFieldBegin('success', TType.I32, 0)
10690 
      oprot.writeI32(self.success)
10691 
      oprot.writeFieldEnd()
10692 
    oprot.writeFieldStop()
10693 
    oprot.writeStructEnd()
10694 
 
10695 
  def validate(self):
10696 
    return
10697 
 
10698 
 
10699 
  def __repr__(self):
10700 
    L = ['%s=%r' % (key, value)
10701 
      for key, value in self.__dict__.iteritems()]
10702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10703 
 
10704 
  def __eq__(self, other):
10705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10706 
 
10707 
  def __ne__(self, other):
10708 
    return not (self == other)
10709 
 
10710 
class getBestSellers_args:
10711 
 
10712 
  thrift_spec = (
10713 
  )
10714 
 
10715 
  def read(self, iprot):
10716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10718 
      return
10719 
    iprot.readStructBegin()
10720 
    while True:
10721 
      (fname, ftype, fid) = iprot.readFieldBegin()
10722 
      if ftype == TType.STOP:
10723 
        break
10724 
      else:
10725 
        iprot.skip(ftype)
10726 
      iprot.readFieldEnd()
10727 
    iprot.readStructEnd()
10728 
 
10729 
  def write(self, oprot):
10730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10732 
      return
10733 
    oprot.writeStructBegin('getBestSellers_args')
10734 
    oprot.writeFieldStop()
10735 
    oprot.writeStructEnd()
10736 
 
10737 
  def validate(self):
10738 
    return
10739 
 
10740 
 
10741 
  def __repr__(self):
10742 
    L = ['%s=%r' % (key, value)
10743 
      for key, value in self.__dict__.iteritems()]
10744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10745 
 
10746 
  def __eq__(self, other):
10747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10748 
 
10749 
  def __ne__(self, other):
10750 
    return not (self == other)
10751 
 
10752 
class getBestSellers_result:
10753 
  """
10754 
  Attributes:
10755 
   - success
10756 
   - isex
10757 
  """
10758 
 
10759 
  thrift_spec = (
10760 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10761 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10762 
  )
10763 
 
10764 
  def __init__(self, success=None, isex=None,):
10765 
    self.success = success
10766 
    self.isex = isex
10767 
 
10768 
  def read(self, iprot):
10769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10771 
      return
10772 
    iprot.readStructBegin()
10773 
    while True:
10774 
      (fname, ftype, fid) = iprot.readFieldBegin()
10775 
      if ftype == TType.STOP:
10776 
        break
10777 
      if fid == 0:
10778 
        if ftype == TType.LIST:
10779 
          self.success = []
8590 kshitij.so 10780 
          (_etype91, _size88) = iprot.readListBegin()
10781 
          for _i92 in xrange(_size88):
10782 
            _elem93 = Item()
10783 
            _elem93.read(iprot)
10784 
            self.success.append(_elem93)
5944 mandeep.dh 10785 
          iprot.readListEnd()
10786 
        else:
10787 
          iprot.skip(ftype)
10788 
      elif fid == 1:
10789 
        if ftype == TType.STRUCT:
10790 
          self.isex = CatalogServiceException()
10791 
          self.isex.read(iprot)
10792 
        else:
10793 
          iprot.skip(ftype)
10794 
      else:
10795 
        iprot.skip(ftype)
10796 
      iprot.readFieldEnd()
10797 
    iprot.readStructEnd()
10798 
 
10799 
  def write(self, oprot):
10800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10802 
      return
10803 
    oprot.writeStructBegin('getBestSellers_result')
10804 
    if self.success is not None:
10805 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10806 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10807 
      for iter94 in self.success:
10808 
        iter94.write(oprot)
5944 mandeep.dh 10809 
      oprot.writeListEnd()
10810 
      oprot.writeFieldEnd()
10811 
    if self.isex is not None:
10812 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10813 
      self.isex.write(oprot)
10814 
      oprot.writeFieldEnd()
10815 
    oprot.writeFieldStop()
10816 
    oprot.writeStructEnd()
10817 
 
10818 
  def validate(self):
10819 
    return
10820 
 
10821 
 
10822 
  def __repr__(self):
10823 
    L = ['%s=%r' % (key, value)
10824 
      for key, value in self.__dict__.iteritems()]
10825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10826 
 
10827 
  def __eq__(self, other):
10828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10829 
 
10830 
  def __ne__(self, other):
10831 
    return not (self == other)
10832 
 
10833 
class getBestSellersCatalogIds_args:
10834 
  """
10835 
  Attributes:
10836 
   - beginIndex
10837 
   - totalItems
10838 
   - brand
10839 
   - category
10840 
  """
10841 
 
10842 
  thrift_spec = (
10843 
    None, # 0
10844 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10845 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10846 
    (3, TType.STRING, 'brand', None, None, ), # 3
10847 
    (4, TType.I64, 'category', None, None, ), # 4
10848 
  )
10849 
 
10850 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10851 
    self.beginIndex = beginIndex
10852 
    self.totalItems = totalItems
10853 
    self.brand = brand
10854 
    self.category = category
10855 
 
10856 
  def read(self, iprot):
10857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10859 
      return
10860 
    iprot.readStructBegin()
10861 
    while True:
10862 
      (fname, ftype, fid) = iprot.readFieldBegin()
10863 
      if ftype == TType.STOP:
10864 
        break
10865 
      if fid == 1:
10866 
        if ftype == TType.I64:
10867 
          self.beginIndex = iprot.readI64();
10868 
        else:
10869 
          iprot.skip(ftype)
10870 
      elif fid == 2:
10871 
        if ftype == TType.I64:
10872 
          self.totalItems = iprot.readI64();
10873 
        else:
10874 
          iprot.skip(ftype)
10875 
      elif fid == 3:
10876 
        if ftype == TType.STRING:
10877 
          self.brand = iprot.readString();
10878 
        else:
10879 
          iprot.skip(ftype)
10880 
      elif fid == 4:
10881 
        if ftype == TType.I64:
10882 
          self.category = iprot.readI64();
10883 
        else:
10884 
          iprot.skip(ftype)
10885 
      else:
10886 
        iprot.skip(ftype)
10887 
      iprot.readFieldEnd()
10888 
    iprot.readStructEnd()
10889 
 
10890 
  def write(self, oprot):
10891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10893 
      return
10894 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
10895 
    if self.beginIndex is not None:
10896 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10897 
      oprot.writeI64(self.beginIndex)
10898 
      oprot.writeFieldEnd()
10899 
    if self.totalItems is not None:
10900 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10901 
      oprot.writeI64(self.totalItems)
10902 
      oprot.writeFieldEnd()
10903 
    if self.brand is not None:
10904 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10905 
      oprot.writeString(self.brand)
10906 
      oprot.writeFieldEnd()
10907 
    if self.category is not None:
10908 
      oprot.writeFieldBegin('category', TType.I64, 4)
10909 
      oprot.writeI64(self.category)
10910 
      oprot.writeFieldEnd()
10911 
    oprot.writeFieldStop()
10912 
    oprot.writeStructEnd()
10913 
 
10914 
  def validate(self):
10915 
    return
10916 
 
10917 
 
10918 
  def __repr__(self):
10919 
    L = ['%s=%r' % (key, value)
10920 
      for key, value in self.__dict__.iteritems()]
10921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10922 
 
10923 
  def __eq__(self, other):
10924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10925 
 
10926 
  def __ne__(self, other):
10927 
    return not (self == other)
10928 
 
10929 
class getBestSellersCatalogIds_result:
10930 
  """
10931 
  Attributes:
10932 
   - success
10933 
   - cex
10934 
  """
10935 
 
10936 
  thrift_spec = (
10937 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10938 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10939 
  )
10940 
 
10941 
  def __init__(self, success=None, cex=None,):
10942 
    self.success = success
10943 
    self.cex = cex
10944 
 
10945 
  def read(self, iprot):
10946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10948 
      return
10949 
    iprot.readStructBegin()
10950 
    while True:
10951 
      (fname, ftype, fid) = iprot.readFieldBegin()
10952 
      if ftype == TType.STOP:
10953 
        break
10954 
      if fid == 0:
10955 
        if ftype == TType.LIST:
10956 
          self.success = []
8590 kshitij.so 10957 
          (_etype98, _size95) = iprot.readListBegin()
10958 
          for _i99 in xrange(_size95):
10959 
            _elem100 = iprot.readI64();
10960 
            self.success.append(_elem100)
5944 mandeep.dh 10961 
          iprot.readListEnd()
10962 
        else:
10963 
          iprot.skip(ftype)
10964 
      elif fid == 1:
10965 
        if ftype == TType.STRUCT:
10966 
          self.cex = CatalogServiceException()
10967 
          self.cex.read(iprot)
10968 
        else:
10969 
          iprot.skip(ftype)
10970 
      else:
10971 
        iprot.skip(ftype)
10972 
      iprot.readFieldEnd()
10973 
    iprot.readStructEnd()
10974 
 
10975 
  def write(self, oprot):
10976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10978 
      return
10979 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
10980 
    if self.success is not None:
10981 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10982 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10983 
      for iter101 in self.success:
10984 
        oprot.writeI64(iter101)
5944 mandeep.dh 10985 
      oprot.writeListEnd()
10986 
      oprot.writeFieldEnd()
10987 
    if self.cex is not None:
10988 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10989 
      self.cex.write(oprot)
10990 
      oprot.writeFieldEnd()
10991 
    oprot.writeFieldStop()
10992 
    oprot.writeStructEnd()
10993 
 
10994 
  def validate(self):
10995 
    return
10996 
 
10997 
 
10998 
  def __repr__(self):
10999 
    L = ['%s=%r' % (key, value)
11000 
      for key, value in self.__dict__.iteritems()]
11001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11002 
 
11003 
  def __eq__(self, other):
11004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11005 
 
11006 
  def __ne__(self, other):
11007 
    return not (self == other)
11008 
 
11009 
class getBestSellersCount_args:
11010 
 
11011 
  thrift_spec = (
11012 
  )
11013 
 
11014 
  def read(self, iprot):
11015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11017 
      return
11018 
    iprot.readStructBegin()
11019 
    while True:
11020 
      (fname, ftype, fid) = iprot.readFieldBegin()
11021 
      if ftype == TType.STOP:
11022 
        break
11023 
      else:
11024 
        iprot.skip(ftype)
11025 
      iprot.readFieldEnd()
11026 
    iprot.readStructEnd()
11027 
 
11028 
  def write(self, oprot):
11029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11031 
      return
11032 
    oprot.writeStructBegin('getBestSellersCount_args')
11033 
    oprot.writeFieldStop()
11034 
    oprot.writeStructEnd()
11035 
 
11036 
  def validate(self):
11037 
    return
11038 
 
11039 
 
11040 
  def __repr__(self):
11041 
    L = ['%s=%r' % (key, value)
11042 
      for key, value in self.__dict__.iteritems()]
11043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11044 
 
11045 
  def __eq__(self, other):
11046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11047 
 
11048 
  def __ne__(self, other):
11049 
    return not (self == other)
11050 
 
11051 
class getBestSellersCount_result:
11052 
  """
11053 
  Attributes:
11054 
   - success
11055 
   - cex
11056 
  """
11057 
 
11058 
  thrift_spec = (
11059 
    (0, TType.I64, 'success', None, None, ), # 0
11060 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11061 
  )
11062 
 
11063 
  def __init__(self, success=None, cex=None,):
11064 
    self.success = success
11065 
    self.cex = cex
11066 
 
11067 
  def read(self, iprot):
11068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11070 
      return
11071 
    iprot.readStructBegin()
11072 
    while True:
11073 
      (fname, ftype, fid) = iprot.readFieldBegin()
11074 
      if ftype == TType.STOP:
11075 
        break
11076 
      if fid == 0:
11077 
        if ftype == TType.I64:
11078 
          self.success = iprot.readI64();
11079 
        else:
11080 
          iprot.skip(ftype)
11081 
      elif fid == 1:
11082 
        if ftype == TType.STRUCT:
11083 
          self.cex = CatalogServiceException()
11084 
          self.cex.read(iprot)
11085 
        else:
11086 
          iprot.skip(ftype)
11087 
      else:
11088 
        iprot.skip(ftype)
11089 
      iprot.readFieldEnd()
11090 
    iprot.readStructEnd()
11091 
 
11092 
  def write(self, oprot):
11093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11095 
      return
11096 
    oprot.writeStructBegin('getBestSellersCount_result')
11097 
    if self.success is not None:
11098 
      oprot.writeFieldBegin('success', TType.I64, 0)
11099 
      oprot.writeI64(self.success)
11100 
      oprot.writeFieldEnd()
11101 
    if self.cex is not None:
11102 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11103 
      self.cex.write(oprot)
11104 
      oprot.writeFieldEnd()
11105 
    oprot.writeFieldStop()
11106 
    oprot.writeStructEnd()
11107 
 
11108 
  def validate(self):
11109 
    return
11110 
 
11111 
 
11112 
  def __repr__(self):
11113 
    L = ['%s=%r' % (key, value)
11114 
      for key, value in self.__dict__.iteritems()]
11115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11116 
 
11117 
  def __eq__(self, other):
11118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11119 
 
11120 
  def __ne__(self, other):
11121 
    return not (self == other)
11122 
 
11123 
class getBestDeals_args:
11124 
 
11125 
  thrift_spec = (
11126 
  )
11127 
 
11128 
  def read(self, iprot):
11129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11131 
      return
11132 
    iprot.readStructBegin()
11133 
    while True:
11134 
      (fname, ftype, fid) = iprot.readFieldBegin()
11135 
      if ftype == TType.STOP:
11136 
        break
11137 
      else:
11138 
        iprot.skip(ftype)
11139 
      iprot.readFieldEnd()
11140 
    iprot.readStructEnd()
11141 
 
11142 
  def write(self, oprot):
11143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11145 
      return
11146 
    oprot.writeStructBegin('getBestDeals_args')
11147 
    oprot.writeFieldStop()
11148 
    oprot.writeStructEnd()
11149 
 
11150 
  def validate(self):
11151 
    return
11152 
 
11153 
 
11154 
  def __repr__(self):
11155 
    L = ['%s=%r' % (key, value)
11156 
      for key, value in self.__dict__.iteritems()]
11157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11158 
 
11159 
  def __eq__(self, other):
11160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11161 
 
11162 
  def __ne__(self, other):
11163 
    return not (self == other)
11164 
 
11165 
class getBestDeals_result:
11166 
  """
11167 
  Attributes:
11168 
   - success
11169 
   - isex
11170 
  """
11171 
 
11172 
  thrift_spec = (
11173 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11174 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11175 
  )
11176 
 
11177 
  def __init__(self, success=None, isex=None,):
11178 
    self.success = success
11179 
    self.isex = isex
11180 
 
11181 
  def read(self, iprot):
11182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11184 
      return
11185 
    iprot.readStructBegin()
11186 
    while True:
11187 
      (fname, ftype, fid) = iprot.readFieldBegin()
11188 
      if ftype == TType.STOP:
11189 
        break
11190 
      if fid == 0:
11191 
        if ftype == TType.LIST:
11192 
          self.success = []
8590 kshitij.so 11193 
          (_etype105, _size102) = iprot.readListBegin()
11194 
          for _i106 in xrange(_size102):
11195 
            _elem107 = Item()
11196 
            _elem107.read(iprot)
11197 
            self.success.append(_elem107)
5944 mandeep.dh 11198 
          iprot.readListEnd()
11199 
        else:
11200 
          iprot.skip(ftype)
11201 
      elif fid == 1:
11202 
        if ftype == TType.STRUCT:
11203 
          self.isex = CatalogServiceException()
11204 
          self.isex.read(iprot)
11205 
        else:
11206 
          iprot.skip(ftype)
11207 
      else:
11208 
        iprot.skip(ftype)
11209 
      iprot.readFieldEnd()
11210 
    iprot.readStructEnd()
11211 
 
11212 
  def write(self, oprot):
11213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11215 
      return
11216 
    oprot.writeStructBegin('getBestDeals_result')
11217 
    if self.success is not None:
11218 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11219 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11220 
      for iter108 in self.success:
11221 
        iter108.write(oprot)
5944 mandeep.dh 11222 
      oprot.writeListEnd()
11223 
      oprot.writeFieldEnd()
11224 
    if self.isex is not None:
11225 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11226 
      self.isex.write(oprot)
11227 
      oprot.writeFieldEnd()
11228 
    oprot.writeFieldStop()
11229 
    oprot.writeStructEnd()
11230 
 
11231 
  def validate(self):
11232 
    return
11233 
 
11234 
 
11235 
  def __repr__(self):
11236 
    L = ['%s=%r' % (key, value)
11237 
      for key, value in self.__dict__.iteritems()]
11238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11239 
 
11240 
  def __eq__(self, other):
11241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11242 
 
11243 
  def __ne__(self, other):
11244 
    return not (self == other)
11245 
 
11246 
class getBestDealsCatalogIds_args:
11247 
  """
11248 
  Attributes:
11249 
   - beginIndex
11250 
   - totalItems
11251 
   - brand
11252 
   - category
11253 
  """
11254 
 
11255 
  thrift_spec = (
11256 
    None, # 0
11257 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11258 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11259 
    (3, TType.STRING, 'brand', None, None, ), # 3
11260 
    (4, TType.I64, 'category', None, None, ), # 4
11261 
  )
11262 
 
11263 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
11264 
    self.beginIndex = beginIndex
11265 
    self.totalItems = totalItems
11266 
    self.brand = brand
11267 
    self.category = category
11268 
 
11269 
  def read(self, iprot):
11270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11272 
      return
11273 
    iprot.readStructBegin()
11274 
    while True:
11275 
      (fname, ftype, fid) = iprot.readFieldBegin()
11276 
      if ftype == TType.STOP:
11277 
        break
11278 
      if fid == 1:
11279 
        if ftype == TType.I64:
11280 
          self.beginIndex = iprot.readI64();
11281 
        else:
11282 
          iprot.skip(ftype)
11283 
      elif fid == 2:
11284 
        if ftype == TType.I64:
11285 
          self.totalItems = iprot.readI64();
11286 
        else:
11287 
          iprot.skip(ftype)
11288 
      elif fid == 3:
11289 
        if ftype == TType.STRING:
11290 
          self.brand = iprot.readString();
11291 
        else:
11292 
          iprot.skip(ftype)
11293 
      elif fid == 4:
11294 
        if ftype == TType.I64:
11295 
          self.category = iprot.readI64();
11296 
        else:
11297 
          iprot.skip(ftype)
11298 
      else:
11299 
        iprot.skip(ftype)
11300 
      iprot.readFieldEnd()
11301 
    iprot.readStructEnd()
11302 
 
11303 
  def write(self, oprot):
11304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11306 
      return
11307 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
11308 
    if self.beginIndex is not None:
11309 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11310 
      oprot.writeI64(self.beginIndex)
11311 
      oprot.writeFieldEnd()
11312 
    if self.totalItems is not None:
11313 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11314 
      oprot.writeI64(self.totalItems)
11315 
      oprot.writeFieldEnd()
11316 
    if self.brand is not None:
11317 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11318 
      oprot.writeString(self.brand)
11319 
      oprot.writeFieldEnd()
11320 
    if self.category is not None:
11321 
      oprot.writeFieldBegin('category', TType.I64, 4)
11322 
      oprot.writeI64(self.category)
11323 
      oprot.writeFieldEnd()
11324 
    oprot.writeFieldStop()
11325 
    oprot.writeStructEnd()
11326 
 
11327 
  def validate(self):
11328 
    return
11329 
 
11330 
 
11331 
  def __repr__(self):
11332 
    L = ['%s=%r' % (key, value)
11333 
      for key, value in self.__dict__.iteritems()]
11334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11335 
 
11336 
  def __eq__(self, other):
11337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11338 
 
11339 
  def __ne__(self, other):
11340 
    return not (self == other)
11341 
 
11342 
class getBestDealsCatalogIds_result:
11343 
  """
11344 
  Attributes:
11345 
   - success
11346 
   - cex
11347 
  """
11348 
 
11349 
  thrift_spec = (
11350 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11351 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11352 
  )
11353 
 
11354 
  def __init__(self, success=None, cex=None,):
11355 
    self.success = success
11356 
    self.cex = cex
11357 
 
11358 
  def read(self, iprot):
11359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11361 
      return
11362 
    iprot.readStructBegin()
11363 
    while True:
11364 
      (fname, ftype, fid) = iprot.readFieldBegin()
11365 
      if ftype == TType.STOP:
11366 
        break
11367 
      if fid == 0:
11368 
        if ftype == TType.LIST:
11369 
          self.success = []
8590 kshitij.so 11370 
          (_etype112, _size109) = iprot.readListBegin()
11371 
          for _i113 in xrange(_size109):
11372 
            _elem114 = iprot.readI64();
11373 
            self.success.append(_elem114)
5944 mandeep.dh 11374 
          iprot.readListEnd()
11375 
        else:
11376 
          iprot.skip(ftype)
11377 
      elif fid == 1:
11378 
        if ftype == TType.STRUCT:
11379 
          self.cex = CatalogServiceException()
11380 
          self.cex.read(iprot)
11381 
        else:
11382 
          iprot.skip(ftype)
11383 
      else:
11384 
        iprot.skip(ftype)
11385 
      iprot.readFieldEnd()
11386 
    iprot.readStructEnd()
11387 
 
11388 
  def write(self, oprot):
11389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11391 
      return
11392 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
11393 
    if self.success is not None:
11394 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11395 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11396 
      for iter115 in self.success:
11397 
        oprot.writeI64(iter115)
5944 mandeep.dh 11398 
      oprot.writeListEnd()
11399 
      oprot.writeFieldEnd()
11400 
    if self.cex is not None:
11401 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11402 
      self.cex.write(oprot)
11403 
      oprot.writeFieldEnd()
11404 
    oprot.writeFieldStop()
11405 
    oprot.writeStructEnd()
11406 
 
11407 
  def validate(self):
11408 
    return
11409 
 
11410 
 
11411 
  def __repr__(self):
11412 
    L = ['%s=%r' % (key, value)
11413 
      for key, value in self.__dict__.iteritems()]
11414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11415 
 
11416 
  def __eq__(self, other):
11417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11418 
 
11419 
  def __ne__(self, other):
11420 
    return not (self == other)
11421 
 
11422 
class getBestDealsCount_args:
11423 
 
11424 
  thrift_spec = (
11425 
  )
11426 
 
11427 
  def read(self, iprot):
11428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11430 
      return
11431 
    iprot.readStructBegin()
11432 
    while True:
11433 
      (fname, ftype, fid) = iprot.readFieldBegin()
11434 
      if ftype == TType.STOP:
11435 
        break
11436 
      else:
11437 
        iprot.skip(ftype)
11438 
      iprot.readFieldEnd()
11439 
    iprot.readStructEnd()
11440 
 
11441 
  def write(self, oprot):
11442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11444 
      return
11445 
    oprot.writeStructBegin('getBestDealsCount_args')
11446 
    oprot.writeFieldStop()
11447 
    oprot.writeStructEnd()
11448 
 
11449 
  def validate(self):
11450 
    return
11451 
 
11452 
 
11453 
  def __repr__(self):
11454 
    L = ['%s=%r' % (key, value)
11455 
      for key, value in self.__dict__.iteritems()]
11456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11457 
 
11458 
  def __eq__(self, other):
11459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11460 
 
11461 
  def __ne__(self, other):
11462 
    return not (self == other)
11463 
 
11464 
class getBestDealsCount_result:
11465 
  """
11466 
  Attributes:
11467 
   - success
11468 
   - cex
11469 
  """
11470 
 
11471 
  thrift_spec = (
11472 
    (0, TType.I64, 'success', None, None, ), # 0
11473 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11474 
  )
11475 
 
11476 
  def __init__(self, success=None, cex=None,):
11477 
    self.success = success
11478 
    self.cex = cex
11479 
 
11480 
  def read(self, iprot):
11481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11483 
      return
11484 
    iprot.readStructBegin()
11485 
    while True:
11486 
      (fname, ftype, fid) = iprot.readFieldBegin()
11487 
      if ftype == TType.STOP:
11488 
        break
11489 
      if fid == 0:
11490 
        if ftype == TType.I64:
11491 
          self.success = iprot.readI64();
11492 
        else:
11493 
          iprot.skip(ftype)
11494 
      elif fid == 1:
11495 
        if ftype == TType.STRUCT:
11496 
          self.cex = CatalogServiceException()
11497 
          self.cex.read(iprot)
11498 
        else:
11499 
          iprot.skip(ftype)
11500 
      else:
11501 
        iprot.skip(ftype)
11502 
      iprot.readFieldEnd()
11503 
    iprot.readStructEnd()
11504 
 
11505 
  def write(self, oprot):
11506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11508 
      return
11509 
    oprot.writeStructBegin('getBestDealsCount_result')
11510 
    if self.success is not None:
11511 
      oprot.writeFieldBegin('success', TType.I64, 0)
11512 
      oprot.writeI64(self.success)
11513 
      oprot.writeFieldEnd()
11514 
    if self.cex is not None:
11515 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11516 
      self.cex.write(oprot)
11517 
      oprot.writeFieldEnd()
11518 
    oprot.writeFieldStop()
11519 
    oprot.writeStructEnd()
11520 
 
11521 
  def validate(self):
11522 
    return
11523 
 
11524 
 
11525 
  def __repr__(self):
11526 
    L = ['%s=%r' % (key, value)
11527 
      for key, value in self.__dict__.iteritems()]
11528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11529 
 
11530 
  def __eq__(self, other):
11531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11532 
 
11533 
  def __ne__(self, other):
11534 
    return not (self == other)
11535 
 
11536 
class getComingSoon_args:
11537 
 
11538 
  thrift_spec = (
11539 
  )
11540 
 
11541 
  def read(self, iprot):
11542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11544 
      return
11545 
    iprot.readStructBegin()
11546 
    while True:
11547 
      (fname, ftype, fid) = iprot.readFieldBegin()
11548 
      if ftype == TType.STOP:
11549 
        break
11550 
      else:
11551 
        iprot.skip(ftype)
11552 
      iprot.readFieldEnd()
11553 
    iprot.readStructEnd()
11554 
 
11555 
  def write(self, oprot):
11556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11558 
      return
11559 
    oprot.writeStructBegin('getComingSoon_args')
11560 
    oprot.writeFieldStop()
11561 
    oprot.writeStructEnd()
11562 
 
11563 
  def validate(self):
11564 
    return
11565 
 
11566 
 
11567 
  def __repr__(self):
11568 
    L = ['%s=%r' % (key, value)
11569 
      for key, value in self.__dict__.iteritems()]
11570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11571 
 
11572 
  def __eq__(self, other):
11573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11574 
 
11575 
  def __ne__(self, other):
11576 
    return not (self == other)
11577 
 
11578 
class getComingSoon_result:
11579 
  """
11580 
  Attributes:
11581 
   - success
11582 
   - isex
11583 
  """
11584 
 
11585 
  thrift_spec = (
11586 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11587 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11588 
  )
11589 
 
11590 
  def __init__(self, success=None, isex=None,):
11591 
    self.success = success
11592 
    self.isex = isex
11593 
 
11594 
  def read(self, iprot):
11595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11597 
      return
11598 
    iprot.readStructBegin()
11599 
    while True:
11600 
      (fname, ftype, fid) = iprot.readFieldBegin()
11601 
      if ftype == TType.STOP:
11602 
        break
11603 
      if fid == 0:
11604 
        if ftype == TType.LIST:
11605 
          self.success = []
8590 kshitij.so 11606 
          (_etype119, _size116) = iprot.readListBegin()
11607 
          for _i120 in xrange(_size116):
11608 
            _elem121 = Item()
11609 
            _elem121.read(iprot)
11610 
            self.success.append(_elem121)
5944 mandeep.dh 11611 
          iprot.readListEnd()
11612 
        else:
11613 
          iprot.skip(ftype)
11614 
      elif fid == 1:
11615 
        if ftype == TType.STRUCT:
11616 
          self.isex = CatalogServiceException()
11617 
          self.isex.read(iprot)
11618 
        else:
11619 
          iprot.skip(ftype)
11620 
      else:
11621 
        iprot.skip(ftype)
11622 
      iprot.readFieldEnd()
11623 
    iprot.readStructEnd()
11624 
 
11625 
  def write(self, oprot):
11626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11628 
      return
11629 
    oprot.writeStructBegin('getComingSoon_result')
11630 
    if self.success is not None:
11631 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11632 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11633 
      for iter122 in self.success:
11634 
        iter122.write(oprot)
5944 mandeep.dh 11635 
      oprot.writeListEnd()
11636 
      oprot.writeFieldEnd()
11637 
    if self.isex is not None:
11638 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11639 
      self.isex.write(oprot)
11640 
      oprot.writeFieldEnd()
11641 
    oprot.writeFieldStop()
11642 
    oprot.writeStructEnd()
11643 
 
11644 
  def validate(self):
11645 
    return
11646 
 
11647 
 
11648 
  def __repr__(self):
11649 
    L = ['%s=%r' % (key, value)
11650 
      for key, value in self.__dict__.iteritems()]
11651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11652 
 
11653 
  def __eq__(self, other):
11654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11655 
 
11656 
  def __ne__(self, other):
11657 
    return not (self == other)
11658 
 
11659 
class getComingSoonCatalogIds_args:
11660 
  """
11661 
  Attributes:
11662 
   - beginIndex
11663 
   - totalItems
11664 
   - brand
11665 
   - category
11666 
  """
11667 
 
11668 
  thrift_spec = (
11669 
    None, # 0
11670 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11671 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11672 
    (3, TType.STRING, 'brand', None, None, ), # 3
11673 
    (4, TType.I64, 'category', None, None, ), # 4
11674 
  )
11675 
 
11676 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
11677 
    self.beginIndex = beginIndex
11678 
    self.totalItems = totalItems
11679 
    self.brand = brand
11680 
    self.category = category
11681 
 
11682 
  def read(self, iprot):
11683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11685 
      return
11686 
    iprot.readStructBegin()
11687 
    while True:
11688 
      (fname, ftype, fid) = iprot.readFieldBegin()
11689 
      if ftype == TType.STOP:
11690 
        break
11691 
      if fid == 1:
11692 
        if ftype == TType.I64:
11693 
          self.beginIndex = iprot.readI64();
11694 
        else:
11695 
          iprot.skip(ftype)
11696 
      elif fid == 2:
11697 
        if ftype == TType.I64:
11698 
          self.totalItems = iprot.readI64();
11699 
        else:
11700 
          iprot.skip(ftype)
11701 
      elif fid == 3:
11702 
        if ftype == TType.STRING:
11703 
          self.brand = iprot.readString();
11704 
        else:
11705 
          iprot.skip(ftype)
11706 
      elif fid == 4:
11707 
        if ftype == TType.I64:
11708 
          self.category = iprot.readI64();
11709 
        else:
11710 
          iprot.skip(ftype)
11711 
      else:
11712 
        iprot.skip(ftype)
11713 
      iprot.readFieldEnd()
11714 
    iprot.readStructEnd()
11715 
 
11716 
  def write(self, oprot):
11717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11719 
      return
11720 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
11721 
    if self.beginIndex is not None:
11722 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11723 
      oprot.writeI64(self.beginIndex)
11724 
      oprot.writeFieldEnd()
11725 
    if self.totalItems is not None:
11726 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11727 
      oprot.writeI64(self.totalItems)
11728 
      oprot.writeFieldEnd()
11729 
    if self.brand is not None:
11730 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11731 
      oprot.writeString(self.brand)
11732 
      oprot.writeFieldEnd()
11733 
    if self.category is not None:
11734 
      oprot.writeFieldBegin('category', TType.I64, 4)
11735 
      oprot.writeI64(self.category)
11736 
      oprot.writeFieldEnd()
11737 
    oprot.writeFieldStop()
11738 
    oprot.writeStructEnd()
11739 
 
11740 
  def validate(self):
11741 
    return
11742 
 
11743 
 
11744 
  def __repr__(self):
11745 
    L = ['%s=%r' % (key, value)
11746 
      for key, value in self.__dict__.iteritems()]
11747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11748 
 
11749 
  def __eq__(self, other):
11750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11751 
 
11752 
  def __ne__(self, other):
11753 
    return not (self == other)
11754 
 
11755 
class getComingSoonCatalogIds_result:
11756 
  """
11757 
  Attributes:
11758 
   - success
11759 
   - cex
11760 
  """
11761 
 
11762 
  thrift_spec = (
11763 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11764 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11765 
  )
11766 
 
11767 
  def __init__(self, success=None, cex=None,):
11768 
    self.success = success
11769 
    self.cex = cex
11770 
 
11771 
  def read(self, iprot):
11772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11774 
      return
11775 
    iprot.readStructBegin()
11776 
    while True:
11777 
      (fname, ftype, fid) = iprot.readFieldBegin()
11778 
      if ftype == TType.STOP:
11779 
        break
11780 
      if fid == 0:
11781 
        if ftype == TType.LIST:
11782 
          self.success = []
8590 kshitij.so 11783 
          (_etype126, _size123) = iprot.readListBegin()
11784 
          for _i127 in xrange(_size123):
11785 
            _elem128 = iprot.readI64();
11786 
            self.success.append(_elem128)
5944 mandeep.dh 11787 
          iprot.readListEnd()
11788 
        else:
11789 
          iprot.skip(ftype)
11790 
      elif fid == 1:
11791 
        if ftype == TType.STRUCT:
11792 
          self.cex = CatalogServiceException()
11793 
          self.cex.read(iprot)
11794 
        else:
11795 
          iprot.skip(ftype)
11796 
      else:
11797 
        iprot.skip(ftype)
11798 
      iprot.readFieldEnd()
11799 
    iprot.readStructEnd()
11800 
 
11801 
  def write(self, oprot):
11802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11804 
      return
11805 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
11806 
    if self.success is not None:
11807 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11808 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11809 
      for iter129 in self.success:
11810 
        oprot.writeI64(iter129)
5944 mandeep.dh 11811 
      oprot.writeListEnd()
11812 
      oprot.writeFieldEnd()
11813 
    if self.cex is not None:
11814 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11815 
      self.cex.write(oprot)
11816 
      oprot.writeFieldEnd()
11817 
    oprot.writeFieldStop()
11818 
    oprot.writeStructEnd()
11819 
 
11820 
  def validate(self):
11821 
    return
11822 
 
11823 
 
11824 
  def __repr__(self):
11825 
    L = ['%s=%r' % (key, value)
11826 
      for key, value in self.__dict__.iteritems()]
11827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11828 
 
11829 
  def __eq__(self, other):
11830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11831 
 
11832 
  def __ne__(self, other):
11833 
    return not (self == other)
11834 
 
11835 
class getComingSoonCount_args:
11836 
 
11837 
  thrift_spec = (
11838 
  )
11839 
 
11840 
  def read(self, iprot):
11841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11843 
      return
11844 
    iprot.readStructBegin()
11845 
    while True:
11846 
      (fname, ftype, fid) = iprot.readFieldBegin()
11847 
      if ftype == TType.STOP:
11848 
        break
11849 
      else:
11850 
        iprot.skip(ftype)
11851 
      iprot.readFieldEnd()
11852 
    iprot.readStructEnd()
11853 
 
11854 
  def write(self, oprot):
11855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11857 
      return
11858 
    oprot.writeStructBegin('getComingSoonCount_args')
11859 
    oprot.writeFieldStop()
11860 
    oprot.writeStructEnd()
11861 
 
11862 
  def validate(self):
11863 
    return
11864 
 
11865 
 
11866 
  def __repr__(self):
11867 
    L = ['%s=%r' % (key, value)
11868 
      for key, value in self.__dict__.iteritems()]
11869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11870 
 
11871 
  def __eq__(self, other):
11872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11873 
 
11874 
  def __ne__(self, other):
11875 
    return not (self == other)
11876 
 
11877 
class getComingSoonCount_result:
11878 
  """
11879 
  Attributes:
11880 
   - success
11881 
   - cex
11882 
  """
11883 
 
11884 
  thrift_spec = (
11885 
    (0, TType.I64, 'success', None, None, ), # 0
11886 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11887 
  )
11888 
 
11889 
  def __init__(self, success=None, cex=None,):
11890 
    self.success = success
11891 
    self.cex = cex
11892 
 
11893 
  def read(self, iprot):
11894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11896 
      return
11897 
    iprot.readStructBegin()
11898 
    while True:
11899 
      (fname, ftype, fid) = iprot.readFieldBegin()
11900 
      if ftype == TType.STOP:
11901 
        break
11902 
      if fid == 0:
11903 
        if ftype == TType.I64:
11904 
          self.success = iprot.readI64();
11905 
        else:
11906 
          iprot.skip(ftype)
11907 
      elif fid == 1:
11908 
        if ftype == TType.STRUCT:
11909 
          self.cex = CatalogServiceException()
11910 
          self.cex.read(iprot)
11911 
        else:
11912 
          iprot.skip(ftype)
11913 
      else:
11914 
        iprot.skip(ftype)
11915 
      iprot.readFieldEnd()
11916 
    iprot.readStructEnd()
11917 
 
11918 
  def write(self, oprot):
11919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11921 
      return
11922 
    oprot.writeStructBegin('getComingSoonCount_result')
11923 
    if self.success is not None:
11924 
      oprot.writeFieldBegin('success', TType.I64, 0)
11925 
      oprot.writeI64(self.success)
11926 
      oprot.writeFieldEnd()
11927 
    if self.cex is not None:
11928 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11929 
      self.cex.write(oprot)
11930 
      oprot.writeFieldEnd()
11931 
    oprot.writeFieldStop()
11932 
    oprot.writeStructEnd()
11933 
 
11934 
  def validate(self):
11935 
    return
11936 
 
11937 
 
11938 
  def __repr__(self):
11939 
    L = ['%s=%r' % (key, value)
11940 
      for key, value in self.__dict__.iteritems()]
11941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11942 
 
11943 
  def __eq__(self, other):
11944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11945 
 
11946 
  def __ne__(self, other):
11947 
    return not (self == other)
11948 
 
11949 
class getLatestArrivals_args:
11950 
 
11951 
  thrift_spec = (
11952 
  )
11953 
 
11954 
  def read(self, iprot):
11955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11957 
      return
11958 
    iprot.readStructBegin()
11959 
    while True:
11960 
      (fname, ftype, fid) = iprot.readFieldBegin()
11961 
      if ftype == TType.STOP:
11962 
        break
11963 
      else:
11964 
        iprot.skip(ftype)
11965 
      iprot.readFieldEnd()
11966 
    iprot.readStructEnd()
11967 
 
11968 
  def write(self, oprot):
11969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11971 
      return
11972 
    oprot.writeStructBegin('getLatestArrivals_args')
11973 
    oprot.writeFieldStop()
11974 
    oprot.writeStructEnd()
11975 
 
11976 
  def validate(self):
11977 
    return
11978 
 
11979 
 
11980 
  def __repr__(self):
11981 
    L = ['%s=%r' % (key, value)
11982 
      for key, value in self.__dict__.iteritems()]
11983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11984 
 
11985 
  def __eq__(self, other):
11986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11987 
 
11988 
  def __ne__(self, other):
11989 
    return not (self == other)
11990 
 
11991 
class getLatestArrivals_result:
11992 
  """
11993 
  Attributes:
11994 
   - success
11995 
   - isex
11996 
  """
11997 
 
11998 
  thrift_spec = (
11999 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12000 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12001 
  )
12002 
 
12003 
  def __init__(self, success=None, isex=None,):
12004 
    self.success = success
12005 
    self.isex = isex
12006 
 
12007 
  def read(self, iprot):
12008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12010 
      return
12011 
    iprot.readStructBegin()
12012 
    while True:
12013 
      (fname, ftype, fid) = iprot.readFieldBegin()
12014 
      if ftype == TType.STOP:
12015 
        break
12016 
      if fid == 0:
12017 
        if ftype == TType.LIST:
12018 
          self.success = []
8590 kshitij.so 12019 
          (_etype133, _size130) = iprot.readListBegin()
12020 
          for _i134 in xrange(_size130):
12021 
            _elem135 = Item()
12022 
            _elem135.read(iprot)
12023 
            self.success.append(_elem135)
5944 mandeep.dh 12024 
          iprot.readListEnd()
12025 
        else:
12026 
          iprot.skip(ftype)
12027 
      elif fid == 1:
12028 
        if ftype == TType.STRUCT:
12029 
          self.isex = CatalogServiceException()
12030 
          self.isex.read(iprot)
12031 
        else:
12032 
          iprot.skip(ftype)
12033 
      else:
12034 
        iprot.skip(ftype)
12035 
      iprot.readFieldEnd()
12036 
    iprot.readStructEnd()
12037 
 
12038 
  def write(self, oprot):
12039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12041 
      return
12042 
    oprot.writeStructBegin('getLatestArrivals_result')
12043 
    if self.success is not None:
12044 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12045 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12046 
      for iter136 in self.success:
12047 
        iter136.write(oprot)
5944 mandeep.dh 12048 
      oprot.writeListEnd()
12049 
      oprot.writeFieldEnd()
12050 
    if self.isex is not None:
12051 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
12052 
      self.isex.write(oprot)
12053 
      oprot.writeFieldEnd()
12054 
    oprot.writeFieldStop()
12055 
    oprot.writeStructEnd()
12056 
 
12057 
  def validate(self):
12058 
    return
12059 
 
12060 
 
12061 
  def __repr__(self):
12062 
    L = ['%s=%r' % (key, value)
12063 
      for key, value in self.__dict__.iteritems()]
12064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12065 
 
12066 
  def __eq__(self, other):
12067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12068 
 
12069 
  def __ne__(self, other):
12070 
    return not (self == other)
12071 
 
12072 
class getLatestArrivalsCatalogIds_args:
12073 
  """
12074 
  Attributes:
12075 
   - beginIndex
12076 
   - totalItems
12077 
   - brand
12078 
   - categories
12079 
  """
12080 
 
12081 
  thrift_spec = (
12082 
    None, # 0
12083 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12084 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12085 
    (3, TType.STRING, 'brand', None, None, ), # 3
12086 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
12087 
  )
12088 
 
12089 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
12090 
    self.beginIndex = beginIndex
12091 
    self.totalItems = totalItems
12092 
    self.brand = brand
12093 
    self.categories = categories
12094 
 
12095 
  def read(self, iprot):
12096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12098 
      return
12099 
    iprot.readStructBegin()
12100 
    while True:
12101 
      (fname, ftype, fid) = iprot.readFieldBegin()
12102 
      if ftype == TType.STOP:
12103 
        break
12104 
      if fid == 1:
12105 
        if ftype == TType.I64:
12106 
          self.beginIndex = iprot.readI64();
12107 
        else:
12108 
          iprot.skip(ftype)
12109 
      elif fid == 2:
12110 
        if ftype == TType.I64:
12111 
          self.totalItems = iprot.readI64();
12112 
        else:
12113 
          iprot.skip(ftype)
12114 
      elif fid == 3:
12115 
        if ftype == TType.STRING:
12116 
          self.brand = iprot.readString();
12117 
        else:
12118 
          iprot.skip(ftype)
12119 
      elif fid == 4:
12120 
        if ftype == TType.LIST:
12121 
          self.categories = []
8590 kshitij.so 12122 
          (_etype140, _size137) = iprot.readListBegin()
12123 
          for _i141 in xrange(_size137):
12124 
            _elem142 = iprot.readI64();
12125 
            self.categories.append(_elem142)
5944 mandeep.dh 12126 
          iprot.readListEnd()
12127 
        else:
12128 
          iprot.skip(ftype)
12129 
      else:
12130 
        iprot.skip(ftype)
12131 
      iprot.readFieldEnd()
12132 
    iprot.readStructEnd()
12133 
 
12134 
  def write(self, oprot):
12135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12137 
      return
12138 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
12139 
    if self.beginIndex is not None:
12140 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12141 
      oprot.writeI64(self.beginIndex)
12142 
      oprot.writeFieldEnd()
12143 
    if self.totalItems is not None:
12144 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12145 
      oprot.writeI64(self.totalItems)
12146 
      oprot.writeFieldEnd()
12147 
    if self.brand is not None:
12148 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
12149 
      oprot.writeString(self.brand)
12150 
      oprot.writeFieldEnd()
12151 
    if self.categories is not None:
12152 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
12153 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 12154 
      for iter143 in self.categories:
12155 
        oprot.writeI64(iter143)
5944 mandeep.dh 12156 
      oprot.writeListEnd()
12157 
      oprot.writeFieldEnd()
12158 
    oprot.writeFieldStop()
12159 
    oprot.writeStructEnd()
12160 
 
12161 
  def validate(self):
12162 
    return
12163 
 
12164 
 
12165 
  def __repr__(self):
12166 
    L = ['%s=%r' % (key, value)
12167 
      for key, value in self.__dict__.iteritems()]
12168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12169 
 
12170 
  def __eq__(self, other):
12171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12172 
 
12173 
  def __ne__(self, other):
12174 
    return not (self == other)
12175 
 
12176 
class getLatestArrivalsCatalogIds_result:
12177 
  """
12178 
  Attributes:
12179 
   - success
12180 
   - cex
12181 
  """
12182 
 
12183 
  thrift_spec = (
12184 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12185 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12186 
  )
12187 
 
12188 
  def __init__(self, success=None, cex=None,):
12189 
    self.success = success
12190 
    self.cex = cex
12191 
 
12192 
  def read(self, iprot):
12193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12195 
      return
12196 
    iprot.readStructBegin()
12197 
    while True:
12198 
      (fname, ftype, fid) = iprot.readFieldBegin()
12199 
      if ftype == TType.STOP:
12200 
        break
12201 
      if fid == 0:
12202 
        if ftype == TType.LIST:
12203 
          self.success = []
8590 kshitij.so 12204 
          (_etype147, _size144) = iprot.readListBegin()
12205 
          for _i148 in xrange(_size144):
12206 
            _elem149 = iprot.readI64();
12207 
            self.success.append(_elem149)
5944 mandeep.dh 12208 
          iprot.readListEnd()
12209 
        else:
12210 
          iprot.skip(ftype)
12211 
      elif fid == 1:
12212 
        if ftype == TType.STRUCT:
12213 
          self.cex = CatalogServiceException()
12214 
          self.cex.read(iprot)
12215 
        else:
12216 
          iprot.skip(ftype)
12217 
      else:
12218 
        iprot.skip(ftype)
12219 
      iprot.readFieldEnd()
12220 
    iprot.readStructEnd()
12221 
 
12222 
  def write(self, oprot):
12223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12225 
      return
12226 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
12227 
    if self.success is not None:
12228 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12229 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12230 
      for iter150 in self.success:
12231 
        oprot.writeI64(iter150)
5944 mandeep.dh 12232 
      oprot.writeListEnd()
12233 
      oprot.writeFieldEnd()
12234 
    if self.cex is not None:
12235 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12236 
      self.cex.write(oprot)
12237 
      oprot.writeFieldEnd()
12238 
    oprot.writeFieldStop()
12239 
    oprot.writeStructEnd()
12240 
 
12241 
  def validate(self):
12242 
    return
12243 
 
12244 
 
12245 
  def __repr__(self):
12246 
    L = ['%s=%r' % (key, value)
12247 
      for key, value in self.__dict__.iteritems()]
12248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12249 
 
12250 
  def __eq__(self, other):
12251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12252 
 
12253 
  def __ne__(self, other):
12254 
    return not (self == other)
12255 
 
12256 
class getLatestArrivalsCount_args:
12257 
 
12258 
  thrift_spec = (
12259 
  )
12260 
 
12261 
  def read(self, iprot):
12262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12264 
      return
12265 
    iprot.readStructBegin()
12266 
    while True:
12267 
      (fname, ftype, fid) = iprot.readFieldBegin()
12268 
      if ftype == TType.STOP:
12269 
        break
12270 
      else:
12271 
        iprot.skip(ftype)
12272 
      iprot.readFieldEnd()
12273 
    iprot.readStructEnd()
12274 
 
12275 
  def write(self, oprot):
12276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12278 
      return
12279 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
12280 
    oprot.writeFieldStop()
12281 
    oprot.writeStructEnd()
12282 
 
12283 
  def validate(self):
12284 
    return
12285 
 
12286 
 
12287 
  def __repr__(self):
12288 
    L = ['%s=%r' % (key, value)
12289 
      for key, value in self.__dict__.iteritems()]
12290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12291 
 
12292 
  def __eq__(self, other):
12293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12294 
 
12295 
  def __ne__(self, other):
12296 
    return not (self == other)
12297 
 
12298 
class getLatestArrivalsCount_result:
12299 
  """
12300 
  Attributes:
12301 
   - success
12302 
   - cex
12303 
  """
12304 
 
12305 
  thrift_spec = (
12306 
    (0, TType.I64, 'success', None, None, ), # 0
12307 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12308 
  )
12309 
 
12310 
  def __init__(self, success=None, cex=None,):
12311 
    self.success = success
12312 
    self.cex = cex
12313 
 
12314 
  def read(self, iprot):
12315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12317 
      return
12318 
    iprot.readStructBegin()
12319 
    while True:
12320 
      (fname, ftype, fid) = iprot.readFieldBegin()
12321 
      if ftype == TType.STOP:
12322 
        break
12323 
      if fid == 0:
12324 
        if ftype == TType.I64:
12325 
          self.success = iprot.readI64();
12326 
        else:
12327 
          iprot.skip(ftype)
12328 
      elif fid == 1:
12329 
        if ftype == TType.STRUCT:
12330 
          self.cex = CatalogServiceException()
12331 
          self.cex.read(iprot)
12332 
        else:
12333 
          iprot.skip(ftype)
12334 
      else:
12335 
        iprot.skip(ftype)
12336 
      iprot.readFieldEnd()
12337 
    iprot.readStructEnd()
12338 
 
12339 
  def write(self, oprot):
12340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12342 
      return
12343 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
12344 
    if self.success is not None:
12345 
      oprot.writeFieldBegin('success', TType.I64, 0)
12346 
      oprot.writeI64(self.success)
12347 
      oprot.writeFieldEnd()
12348 
    if self.cex is not None:
12349 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12350 
      self.cex.write(oprot)
12351 
      oprot.writeFieldEnd()
12352 
    oprot.writeFieldStop()
12353 
    oprot.writeStructEnd()
12354 
 
12355 
  def validate(self):
12356 
    return
12357 
 
12358 
 
12359 
  def __repr__(self):
12360 
    L = ['%s=%r' % (key, value)
12361 
      for key, value in self.__dict__.iteritems()]
12362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12363 
 
12364 
  def __eq__(self, other):
12365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12366 
 
12367 
  def __ne__(self, other):
12368 
    return not (self == other)
12369 
 
12370 
class generateNewEntityID_args:
12371 
 
12372 
  thrift_spec = (
12373 
  )
12374 
 
12375 
  def read(self, iprot):
12376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12378 
      return
12379 
    iprot.readStructBegin()
12380 
    while True:
12381 
      (fname, ftype, fid) = iprot.readFieldBegin()
12382 
      if ftype == TType.STOP:
12383 
        break
12384 
      else:
12385 
        iprot.skip(ftype)
12386 
      iprot.readFieldEnd()
12387 
    iprot.readStructEnd()
12388 
 
12389 
  def write(self, oprot):
12390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12392 
      return
12393 
    oprot.writeStructBegin('generateNewEntityID_args')
12394 
    oprot.writeFieldStop()
12395 
    oprot.writeStructEnd()
12396 
 
12397 
  def validate(self):
12398 
    return
12399 
 
12400 
 
12401 
  def __repr__(self):
12402 
    L = ['%s=%r' % (key, value)
12403 
      for key, value in self.__dict__.iteritems()]
12404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12405 
 
12406 
  def __eq__(self, other):
12407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12408 
 
12409 
  def __ne__(self, other):
12410 
    return not (self == other)
12411 
 
12412 
class generateNewEntityID_result:
12413 
  """
12414 
  Attributes:
12415 
   - success
12416 
  """
12417 
 
12418 
  thrift_spec = (
12419 
    (0, TType.I64, 'success', None, None, ), # 0
12420 
  )
12421 
 
12422 
  def __init__(self, success=None,):
12423 
    self.success = success
12424 
 
12425 
  def read(self, iprot):
12426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12428 
      return
12429 
    iprot.readStructBegin()
12430 
    while True:
12431 
      (fname, ftype, fid) = iprot.readFieldBegin()
12432 
      if ftype == TType.STOP:
12433 
        break
12434 
      if fid == 0:
12435 
        if ftype == TType.I64:
12436 
          self.success = iprot.readI64();
12437 
        else:
12438 
          iprot.skip(ftype)
12439 
      else:
12440 
        iprot.skip(ftype)
12441 
      iprot.readFieldEnd()
12442 
    iprot.readStructEnd()
12443 
 
12444 
  def write(self, oprot):
12445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12447 
      return
12448 
    oprot.writeStructBegin('generateNewEntityID_result')
12449 
    if self.success is not None:
12450 
      oprot.writeFieldBegin('success', TType.I64, 0)
12451 
      oprot.writeI64(self.success)
12452 
      oprot.writeFieldEnd()
12453 
    oprot.writeFieldStop()
12454 
    oprot.writeStructEnd()
12455 
 
12456 
  def validate(self):
12457 
    return
12458 
 
12459 
 
12460 
  def __repr__(self):
12461 
    L = ['%s=%r' % (key, value)
12462 
      for key, value in self.__dict__.iteritems()]
12463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12464 
 
12465 
  def __eq__(self, other):
12466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12467 
 
12468 
  def __ne__(self, other):
12469 
    return not (self == other)
12470 
 
12471 
class addCategory_args:
12472 
  """
12473 
  Attributes:
12474 
   - category
12475 
  """
12476 
 
12477 
  thrift_spec = (
12478 
    None, # 0
12479 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
12480 
  )
12481 
 
12482 
  def __init__(self, category=None,):
12483 
    self.category = category
12484 
 
12485 
  def read(self, iprot):
12486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12488 
      return
12489 
    iprot.readStructBegin()
12490 
    while True:
12491 
      (fname, ftype, fid) = iprot.readFieldBegin()
12492 
      if ftype == TType.STOP:
12493 
        break
12494 
      if fid == 1:
12495 
        if ftype == TType.STRUCT:
12496 
          self.category = Category()
12497 
          self.category.read(iprot)
12498 
        else:
12499 
          iprot.skip(ftype)
12500 
      else:
12501 
        iprot.skip(ftype)
12502 
      iprot.readFieldEnd()
12503 
    iprot.readStructEnd()
12504 
 
12505 
  def write(self, oprot):
12506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12508 
      return
12509 
    oprot.writeStructBegin('addCategory_args')
12510 
    if self.category is not None:
12511 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
12512 
      self.category.write(oprot)
12513 
      oprot.writeFieldEnd()
12514 
    oprot.writeFieldStop()
12515 
    oprot.writeStructEnd()
12516 
 
12517 
  def validate(self):
12518 
    return
12519 
 
12520 
 
12521 
  def __repr__(self):
12522 
    L = ['%s=%r' % (key, value)
12523 
      for key, value in self.__dict__.iteritems()]
12524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12525 
 
12526 
  def __eq__(self, other):
12527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12528 
 
12529 
  def __ne__(self, other):
12530 
    return not (self == other)
12531 
 
12532 
class addCategory_result:
12533 
  """
12534 
  Attributes:
12535 
   - success
12536 
  """
12537 
 
12538 
  thrift_spec = (
12539 
    (0, TType.BOOL, 'success', None, None, ), # 0
12540 
  )
12541 
 
12542 
  def __init__(self, success=None,):
12543 
    self.success = success
12544 
 
12545 
  def read(self, iprot):
12546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12548 
      return
12549 
    iprot.readStructBegin()
12550 
    while True:
12551 
      (fname, ftype, fid) = iprot.readFieldBegin()
12552 
      if ftype == TType.STOP:
12553 
        break
12554 
      if fid == 0:
12555 
        if ftype == TType.BOOL:
12556 
          self.success = iprot.readBool();
12557 
        else:
12558 
          iprot.skip(ftype)
12559 
      else:
12560 
        iprot.skip(ftype)
12561 
      iprot.readFieldEnd()
12562 
    iprot.readStructEnd()
12563 
 
12564 
  def write(self, oprot):
12565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12567 
      return
12568 
    oprot.writeStructBegin('addCategory_result')
12569 
    if self.success is not None:
12570 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12571 
      oprot.writeBool(self.success)
12572 
      oprot.writeFieldEnd()
12573 
    oprot.writeFieldStop()
12574 
    oprot.writeStructEnd()
12575 
 
12576 
  def validate(self):
12577 
    return
12578 
 
12579 
 
12580 
  def __repr__(self):
12581 
    L = ['%s=%r' % (key, value)
12582 
      for key, value in self.__dict__.iteritems()]
12583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12584 
 
12585 
  def __eq__(self, other):
12586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12587 
 
12588 
  def __ne__(self, other):
12589 
    return not (self == other)
12590 
 
12591 
class getCategory_args:
12592 
  """
12593 
  Attributes:
12594 
   - id
12595 
  """
12596 
 
12597 
  thrift_spec = (
12598 
    None, # 0
12599 
    (1, TType.I64, 'id', None, None, ), # 1
12600 
  )
12601 
 
12602 
  def __init__(self, id=None,):
12603 
    self.id = id
12604 
 
12605 
  def read(self, iprot):
12606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12608 
      return
12609 
    iprot.readStructBegin()
12610 
    while True:
12611 
      (fname, ftype, fid) = iprot.readFieldBegin()
12612 
      if ftype == TType.STOP:
12613 
        break
12614 
      if fid == 1:
12615 
        if ftype == TType.I64:
12616 
          self.id = iprot.readI64();
12617 
        else:
12618 
          iprot.skip(ftype)
12619 
      else:
12620 
        iprot.skip(ftype)
12621 
      iprot.readFieldEnd()
12622 
    iprot.readStructEnd()
12623 
 
12624 
  def write(self, oprot):
12625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12627 
      return
12628 
    oprot.writeStructBegin('getCategory_args')
12629 
    if self.id is not None:
12630 
      oprot.writeFieldBegin('id', TType.I64, 1)
12631 
      oprot.writeI64(self.id)
12632 
      oprot.writeFieldEnd()
12633 
    oprot.writeFieldStop()
12634 
    oprot.writeStructEnd()
12635 
 
12636 
  def validate(self):
12637 
    return
12638 
 
12639 
 
12640 
  def __repr__(self):
12641 
    L = ['%s=%r' % (key, value)
12642 
      for key, value in self.__dict__.iteritems()]
12643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12644 
 
12645 
  def __eq__(self, other):
12646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12647 
 
12648 
  def __ne__(self, other):
12649 
    return not (self == other)
12650 
 
12651 
class getCategory_result:
12652 
  """
12653 
  Attributes:
12654 
   - success
12655 
  """
12656 
 
12657 
  thrift_spec = (
12658 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
12659 
  )
12660 
 
12661 
  def __init__(self, success=None,):
12662 
    self.success = success
12663 
 
12664 
  def read(self, iprot):
12665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12667 
      return
12668 
    iprot.readStructBegin()
12669 
    while True:
12670 
      (fname, ftype, fid) = iprot.readFieldBegin()
12671 
      if ftype == TType.STOP:
12672 
        break
12673 
      if fid == 0:
12674 
        if ftype == TType.STRUCT:
12675 
          self.success = Category()
12676 
          self.success.read(iprot)
12677 
        else:
12678 
          iprot.skip(ftype)
12679 
      else:
12680 
        iprot.skip(ftype)
12681 
      iprot.readFieldEnd()
12682 
    iprot.readStructEnd()
12683 
 
12684 
  def write(self, oprot):
12685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12687 
      return
12688 
    oprot.writeStructBegin('getCategory_result')
12689 
    if self.success is not None:
12690 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12691 
      self.success.write(oprot)
12692 
      oprot.writeFieldEnd()
12693 
    oprot.writeFieldStop()
12694 
    oprot.writeStructEnd()
12695 
 
12696 
  def validate(self):
12697 
    return
12698 
 
12699 
 
12700 
  def __repr__(self):
12701 
    L = ['%s=%r' % (key, value)
12702 
      for key, value in self.__dict__.iteritems()]
12703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12704 
 
12705 
  def __eq__(self, other):
12706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12707 
 
12708 
  def __ne__(self, other):
12709 
    return not (self == other)
12710 
 
12711 
class getAllCategories_args:
12712 
 
12713 
  thrift_spec = (
12714 
  )
12715 
 
12716 
  def read(self, iprot):
12717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12719 
      return
12720 
    iprot.readStructBegin()
12721 
    while True:
12722 
      (fname, ftype, fid) = iprot.readFieldBegin()
12723 
      if ftype == TType.STOP:
12724 
        break
12725 
      else:
12726 
        iprot.skip(ftype)
12727 
      iprot.readFieldEnd()
12728 
    iprot.readStructEnd()
12729 
 
12730 
  def write(self, oprot):
12731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12733 
      return
12734 
    oprot.writeStructBegin('getAllCategories_args')
12735 
    oprot.writeFieldStop()
12736 
    oprot.writeStructEnd()
12737 
 
12738 
  def validate(self):
12739 
    return
12740 
 
12741 
 
12742 
  def __repr__(self):
12743 
    L = ['%s=%r' % (key, value)
12744 
      for key, value in self.__dict__.iteritems()]
12745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12746 
 
12747 
  def __eq__(self, other):
12748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12749 
 
12750 
  def __ne__(self, other):
12751 
    return not (self == other)
12752 
 
12753 
class getAllCategories_result:
12754 
  """
12755 
  Attributes:
12756 
   - success
12757 
  """
12758 
 
12759 
  thrift_spec = (
12760 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
12761 
  )
12762 
 
12763 
  def __init__(self, success=None,):
12764 
    self.success = success
12765 
 
12766 
  def read(self, iprot):
12767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12769 
      return
12770 
    iprot.readStructBegin()
12771 
    while True:
12772 
      (fname, ftype, fid) = iprot.readFieldBegin()
12773 
      if ftype == TType.STOP:
12774 
        break
12775 
      if fid == 0:
12776 
        if ftype == TType.LIST:
12777 
          self.success = []
8590 kshitij.so 12778 
          (_etype154, _size151) = iprot.readListBegin()
12779 
          for _i155 in xrange(_size151):
12780 
            _elem156 = Category()
12781 
            _elem156.read(iprot)
12782 
            self.success.append(_elem156)
5944 mandeep.dh 12783 
          iprot.readListEnd()
12784 
        else:
12785 
          iprot.skip(ftype)
12786 
      else:
12787 
        iprot.skip(ftype)
12788 
      iprot.readFieldEnd()
12789 
    iprot.readStructEnd()
12790 
 
12791 
  def write(self, oprot):
12792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12794 
      return
12795 
    oprot.writeStructBegin('getAllCategories_result')
12796 
    if self.success is not None:
12797 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12798 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12799 
      for iter157 in self.success:
12800 
        iter157.write(oprot)
5944 mandeep.dh 12801 
      oprot.writeListEnd()
12802 
      oprot.writeFieldEnd()
12803 
    oprot.writeFieldStop()
12804 
    oprot.writeStructEnd()
12805 
 
12806 
  def validate(self):
12807 
    return
12808 
 
12809 
 
12810 
  def __repr__(self):
12811 
    L = ['%s=%r' % (key, value)
12812 
      for key, value in self.__dict__.iteritems()]
12813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12814 
 
12815 
  def __eq__(self, other):
12816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12817 
 
12818 
  def __ne__(self, other):
12819 
    return not (self == other)
12820 
 
12821 
class getAllSimilarItems_args:
12822 
  """
12823 
  Attributes:
12824 
   - itemId
12825 
  """
12826 
 
12827 
  thrift_spec = (
12828 
    None, # 0
12829 
    (1, TType.I64, 'itemId', None, None, ), # 1
12830 
  )
12831 
 
12832 
  def __init__(self, itemId=None,):
12833 
    self.itemId = itemId
12834 
 
12835 
  def read(self, iprot):
12836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12838 
      return
12839 
    iprot.readStructBegin()
12840 
    while True:
12841 
      (fname, ftype, fid) = iprot.readFieldBegin()
12842 
      if ftype == TType.STOP:
12843 
        break
12844 
      if fid == 1:
12845 
        if ftype == TType.I64:
12846 
          self.itemId = iprot.readI64();
12847 
        else:
12848 
          iprot.skip(ftype)
12849 
      else:
12850 
        iprot.skip(ftype)
12851 
      iprot.readFieldEnd()
12852 
    iprot.readStructEnd()
12853 
 
12854 
  def write(self, oprot):
12855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12857 
      return
12858 
    oprot.writeStructBegin('getAllSimilarItems_args')
12859 
    if self.itemId is not None:
12860 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12861 
      oprot.writeI64(self.itemId)
12862 
      oprot.writeFieldEnd()
12863 
    oprot.writeFieldStop()
12864 
    oprot.writeStructEnd()
12865 
 
12866 
  def validate(self):
12867 
    return
12868 
 
12869 
 
12870 
  def __repr__(self):
12871 
    L = ['%s=%r' % (key, value)
12872 
      for key, value in self.__dict__.iteritems()]
12873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12874 
 
12875 
  def __eq__(self, other):
12876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12877 
 
12878 
  def __ne__(self, other):
12879 
    return not (self == other)
12880 
 
12881 
class getAllSimilarItems_result:
12882 
  """
12883 
  Attributes:
12884 
   - success
12885 
  """
12886 
 
12887 
  thrift_spec = (
12888 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12889 
  )
12890 
 
12891 
  def __init__(self, success=None,):
12892 
    self.success = success
12893 
 
12894 
  def read(self, iprot):
12895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12897 
      return
12898 
    iprot.readStructBegin()
12899 
    while True:
12900 
      (fname, ftype, fid) = iprot.readFieldBegin()
12901 
      if ftype == TType.STOP:
12902 
        break
12903 
      if fid == 0:
12904 
        if ftype == TType.LIST:
12905 
          self.success = []
8590 kshitij.so 12906 
          (_etype161, _size158) = iprot.readListBegin()
12907 
          for _i162 in xrange(_size158):
12908 
            _elem163 = Item()
12909 
            _elem163.read(iprot)
12910 
            self.success.append(_elem163)
5944 mandeep.dh 12911 
          iprot.readListEnd()
12912 
        else:
12913 
          iprot.skip(ftype)
12914 
      else:
12915 
        iprot.skip(ftype)
12916 
      iprot.readFieldEnd()
12917 
    iprot.readStructEnd()
12918 
 
12919 
  def write(self, oprot):
12920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12922 
      return
12923 
    oprot.writeStructBegin('getAllSimilarItems_result')
12924 
    if self.success is not None:
12925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12926 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12927 
      for iter164 in self.success:
12928 
        iter164.write(oprot)
5944 mandeep.dh 12929 
      oprot.writeListEnd()
12930 
      oprot.writeFieldEnd()
12931 
    oprot.writeFieldStop()
12932 
    oprot.writeStructEnd()
12933 
 
12934 
  def validate(self):
12935 
    return
12936 
 
12937 
 
12938 
  def __repr__(self):
12939 
    L = ['%s=%r' % (key, value)
12940 
      for key, value in self.__dict__.iteritems()]
12941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12942 
 
12943 
  def __eq__(self, other):
12944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12945 
 
12946 
  def __ne__(self, other):
12947 
    return not (self == other)
12948 
 
12949 
class addSimilarItem_args:
12950 
  """
12951 
  Attributes:
12952 
   - itemId
12953 
   - catalogItemId
12954 
  """
12955 
 
12956 
  thrift_spec = (
12957 
    None, # 0
12958 
    (1, TType.I64, 'itemId', None, None, ), # 1
12959 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
12960 
  )
12961 
 
12962 
  def __init__(self, itemId=None, catalogItemId=None,):
12963 
    self.itemId = itemId
12964 
    self.catalogItemId = catalogItemId
12965 
 
12966 
  def read(self, iprot):
12967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12969 
      return
12970 
    iprot.readStructBegin()
12971 
    while True:
12972 
      (fname, ftype, fid) = iprot.readFieldBegin()
12973 
      if ftype == TType.STOP:
12974 
        break
12975 
      if fid == 1:
12976 
        if ftype == TType.I64:
12977 
          self.itemId = iprot.readI64();
12978 
        else:
12979 
          iprot.skip(ftype)
12980 
      elif fid == 2:
12981 
        if ftype == TType.I64:
12982 
          self.catalogItemId = iprot.readI64();
12983 
        else:
12984 
          iprot.skip(ftype)
12985 
      else:
12986 
        iprot.skip(ftype)
12987 
      iprot.readFieldEnd()
12988 
    iprot.readStructEnd()
12989 
 
12990 
  def write(self, oprot):
12991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12993 
      return
12994 
    oprot.writeStructBegin('addSimilarItem_args')
12995 
    if self.itemId is not None:
12996 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12997 
      oprot.writeI64(self.itemId)
12998 
      oprot.writeFieldEnd()
12999 
    if self.catalogItemId is not None:
13000 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
13001 
      oprot.writeI64(self.catalogItemId)
13002 
      oprot.writeFieldEnd()
13003 
    oprot.writeFieldStop()
13004 
    oprot.writeStructEnd()
13005 
 
13006 
  def validate(self):
13007 
    return
13008 
 
13009 
 
13010 
  def __repr__(self):
13011 
    L = ['%s=%r' % (key, value)
13012 
      for key, value in self.__dict__.iteritems()]
13013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13014 
 
13015 
  def __eq__(self, other):
13016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13017 
 
13018 
  def __ne__(self, other):
13019 
    return not (self == other)
13020 
 
13021 
class addSimilarItem_result:
13022 
  """
13023 
  Attributes:
13024 
   - success
13025 
   - cex
13026 
  """
13027 
 
13028 
  thrift_spec = (
13029 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13030 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13031 
  )
13032 
 
13033 
  def __init__(self, success=None, cex=None,):
13034 
    self.success = success
13035 
    self.cex = cex
13036 
 
13037 
  def read(self, iprot):
13038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13040 
      return
13041 
    iprot.readStructBegin()
13042 
    while True:
13043 
      (fname, ftype, fid) = iprot.readFieldBegin()
13044 
      if ftype == TType.STOP:
13045 
        break
13046 
      if fid == 0:
13047 
        if ftype == TType.STRUCT:
13048 
          self.success = Item()
13049 
          self.success.read(iprot)
13050 
        else:
13051 
          iprot.skip(ftype)
13052 
      elif fid == 1:
13053 
        if ftype == TType.STRUCT:
13054 
          self.cex = CatalogServiceException()
13055 
          self.cex.read(iprot)
13056 
        else:
13057 
          iprot.skip(ftype)
13058 
      else:
13059 
        iprot.skip(ftype)
13060 
      iprot.readFieldEnd()
13061 
    iprot.readStructEnd()
13062 
 
13063 
  def write(self, oprot):
13064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13066 
      return
13067 
    oprot.writeStructBegin('addSimilarItem_result')
13068 
    if self.success is not None:
13069 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13070 
      self.success.write(oprot)
13071 
      oprot.writeFieldEnd()
13072 
    if self.cex is not None:
13073 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13074 
      self.cex.write(oprot)
13075 
      oprot.writeFieldEnd()
13076 
    oprot.writeFieldStop()
13077 
    oprot.writeStructEnd()
13078 
 
13079 
  def validate(self):
13080 
    return
13081 
 
13082 
 
13083 
  def __repr__(self):
13084 
    L = ['%s=%r' % (key, value)
13085 
      for key, value in self.__dict__.iteritems()]
13086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13087 
 
13088 
  def __eq__(self, other):
13089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13090 
 
13091 
  def __ne__(self, other):
13092 
    return not (self == other)
13093 
 
6512 kshitij.so 13094 
class addTag_args:
13095 
  """
13096 
  Attributes:
13097 
   - displayName
13098 
   - itemId
13099 
  """
13100 
 
13101 
  thrift_spec = (
13102 
    None, # 0
13103 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13104 
    (2, TType.I64, 'itemId', None, None, ), # 2
13105 
  )
13106 
 
13107 
  def __init__(self, displayName=None, itemId=None,):
13108 
    self.displayName = displayName
13109 
    self.itemId = itemId
13110 
 
13111 
  def read(self, iprot):
13112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13114 
      return
13115 
    iprot.readStructBegin()
13116 
    while True:
13117 
      (fname, ftype, fid) = iprot.readFieldBegin()
13118 
      if ftype == TType.STOP:
13119 
        break
13120 
      if fid == 1:
13121 
        if ftype == TType.STRING:
13122 
          self.displayName = iprot.readString();
13123 
        else:
13124 
          iprot.skip(ftype)
13125 
      elif fid == 2:
13126 
        if ftype == TType.I64:
13127 
          self.itemId = iprot.readI64();
13128 
        else:
13129 
          iprot.skip(ftype)
13130 
      else:
13131 
        iprot.skip(ftype)
13132 
      iprot.readFieldEnd()
13133 
    iprot.readStructEnd()
13134 
 
13135 
  def write(self, oprot):
13136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13138 
      return
13139 
    oprot.writeStructBegin('addTag_args')
13140 
    if self.displayName is not None:
13141 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13142 
      oprot.writeString(self.displayName)
13143 
      oprot.writeFieldEnd()
13144 
    if self.itemId is not None:
13145 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13146 
      oprot.writeI64(self.itemId)
13147 
      oprot.writeFieldEnd()
13148 
    oprot.writeFieldStop()
13149 
    oprot.writeStructEnd()
13150 
 
13151 
  def validate(self):
13152 
    return
13153 
 
13154 
 
13155 
  def __repr__(self):
13156 
    L = ['%s=%r' % (key, value)
13157 
      for key, value in self.__dict__.iteritems()]
13158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13159 
 
13160 
  def __eq__(self, other):
13161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13162 
 
13163 
  def __ne__(self, other):
13164 
    return not (self == other)
13165 
 
13166 
class addTag_result:
13167 
  """
13168 
  Attributes:
13169 
   - success
13170 
  """
13171 
 
13172 
  thrift_spec = (
13173 
    (0, TType.BOOL, 'success', None, None, ), # 0
13174 
  )
13175 
 
13176 
  def __init__(self, success=None,):
13177 
    self.success = success
13178 
 
13179 
  def read(self, iprot):
13180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13182 
      return
13183 
    iprot.readStructBegin()
13184 
    while True:
13185 
      (fname, ftype, fid) = iprot.readFieldBegin()
13186 
      if ftype == TType.STOP:
13187 
        break
13188 
      if fid == 0:
13189 
        if ftype == TType.BOOL:
13190 
          self.success = iprot.readBool();
13191 
        else:
13192 
          iprot.skip(ftype)
13193 
      else:
13194 
        iprot.skip(ftype)
13195 
      iprot.readFieldEnd()
13196 
    iprot.readStructEnd()
13197 
 
13198 
  def write(self, oprot):
13199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13201 
      return
13202 
    oprot.writeStructBegin('addTag_result')
13203 
    if self.success is not None:
13204 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13205 
      oprot.writeBool(self.success)
13206 
      oprot.writeFieldEnd()
13207 
    oprot.writeFieldStop()
13208 
    oprot.writeStructEnd()
13209 
 
13210 
  def validate(self):
13211 
    return
13212 
 
13213 
 
13214 
  def __repr__(self):
13215 
    L = ['%s=%r' % (key, value)
13216 
      for key, value in self.__dict__.iteritems()]
13217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13218 
 
13219 
  def __eq__(self, other):
13220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13221 
 
13222 
  def __ne__(self, other):
13223 
    return not (self == other)
13224 
 
13225 
class deleteEntityTag_args:
13226 
  """
13227 
  Attributes:
13228 
   - displayName
13229 
   - itemId
13230 
  """
13231 
 
13232 
  thrift_spec = (
13233 
    None, # 0
13234 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13235 
    (2, TType.I64, 'itemId', None, None, ), # 2
13236 
  )
13237 
 
13238 
  def __init__(self, displayName=None, itemId=None,):
13239 
    self.displayName = displayName
13240 
    self.itemId = itemId
13241 
 
13242 
  def read(self, iprot):
13243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13245 
      return
13246 
    iprot.readStructBegin()
13247 
    while True:
13248 
      (fname, ftype, fid) = iprot.readFieldBegin()
13249 
      if ftype == TType.STOP:
13250 
        break
13251 
      if fid == 1:
13252 
        if ftype == TType.STRING:
13253 
          self.displayName = iprot.readString();
13254 
        else:
13255 
          iprot.skip(ftype)
13256 
      elif fid == 2:
13257 
        if ftype == TType.I64:
13258 
          self.itemId = iprot.readI64();
13259 
        else:
13260 
          iprot.skip(ftype)
13261 
      else:
13262 
        iprot.skip(ftype)
13263 
      iprot.readFieldEnd()
13264 
    iprot.readStructEnd()
13265 
 
13266 
  def write(self, oprot):
13267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13269 
      return
13270 
    oprot.writeStructBegin('deleteEntityTag_args')
13271 
    if self.displayName is not None:
13272 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13273 
      oprot.writeString(self.displayName)
13274 
      oprot.writeFieldEnd()
13275 
    if self.itemId is not None:
13276 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13277 
      oprot.writeI64(self.itemId)
13278 
      oprot.writeFieldEnd()
13279 
    oprot.writeFieldStop()
13280 
    oprot.writeStructEnd()
13281 
 
13282 
  def validate(self):
13283 
    return
13284 
 
13285 
 
13286 
  def __repr__(self):
13287 
    L = ['%s=%r' % (key, value)
13288 
      for key, value in self.__dict__.iteritems()]
13289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13290 
 
13291 
  def __eq__(self, other):
13292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13293 
 
13294 
  def __ne__(self, other):
13295 
    return not (self == other)
13296 
 
13297 
class deleteEntityTag_result:
13298 
  """
13299 
  Attributes:
13300 
   - success
13301 
  """
13302 
 
13303 
  thrift_spec = (
13304 
    (0, TType.BOOL, 'success', None, None, ), # 0
13305 
  )
13306 
 
13307 
  def __init__(self, success=None,):
13308 
    self.success = success
13309 
 
13310 
  def read(self, iprot):
13311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13313 
      return
13314 
    iprot.readStructBegin()
13315 
    while True:
13316 
      (fname, ftype, fid) = iprot.readFieldBegin()
13317 
      if ftype == TType.STOP:
13318 
        break
13319 
      if fid == 0:
13320 
        if ftype == TType.BOOL:
13321 
          self.success = iprot.readBool();
13322 
        else:
13323 
          iprot.skip(ftype)
13324 
      else:
13325 
        iprot.skip(ftype)
13326 
      iprot.readFieldEnd()
13327 
    iprot.readStructEnd()
13328 
 
13329 
  def write(self, oprot):
13330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13332 
      return
13333 
    oprot.writeStructBegin('deleteEntityTag_result')
13334 
    if self.success is not None:
13335 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13336 
      oprot.writeBool(self.success)
13337 
      oprot.writeFieldEnd()
13338 
    oprot.writeFieldStop()
13339 
    oprot.writeStructEnd()
13340 
 
13341 
  def validate(self):
13342 
    return
13343 
 
13344 
 
13345 
  def __repr__(self):
13346 
    L = ['%s=%r' % (key, value)
13347 
      for key, value in self.__dict__.iteritems()]
13348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13349 
 
13350 
  def __eq__(self, other):
13351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13352 
 
13353 
  def __ne__(self, other):
13354 
    return not (self == other)
13355 
 
13356 
class deleteTag_args:
13357 
  """
13358 
  Attributes:
13359 
   - displayName
13360 
  """
13361 
 
13362 
  thrift_spec = (
13363 
    None, # 0
13364 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13365 
  )
13366 
 
13367 
  def __init__(self, displayName=None,):
13368 
    self.displayName = displayName
13369 
 
13370 
  def read(self, iprot):
13371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13373 
      return
13374 
    iprot.readStructBegin()
13375 
    while True:
13376 
      (fname, ftype, fid) = iprot.readFieldBegin()
13377 
      if ftype == TType.STOP:
13378 
        break
13379 
      if fid == 1:
13380 
        if ftype == TType.STRING:
13381 
          self.displayName = iprot.readString();
13382 
        else:
13383 
          iprot.skip(ftype)
13384 
      else:
13385 
        iprot.skip(ftype)
13386 
      iprot.readFieldEnd()
13387 
    iprot.readStructEnd()
13388 
 
13389 
  def write(self, oprot):
13390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13392 
      return
13393 
    oprot.writeStructBegin('deleteTag_args')
13394 
    if self.displayName is not None:
13395 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13396 
      oprot.writeString(self.displayName)
13397 
      oprot.writeFieldEnd()
13398 
    oprot.writeFieldStop()
13399 
    oprot.writeStructEnd()
13400 
 
13401 
  def validate(self):
13402 
    return
13403 
 
13404 
 
13405 
  def __repr__(self):
13406 
    L = ['%s=%r' % (key, value)
13407 
      for key, value in self.__dict__.iteritems()]
13408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13409 
 
13410 
  def __eq__(self, other):
13411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13412 
 
13413 
  def __ne__(self, other):
13414 
    return not (self == other)
13415 
 
13416 
class deleteTag_result:
13417 
  """
13418 
  Attributes:
13419 
   - success
13420 
  """
13421 
 
13422 
  thrift_spec = (
13423 
    (0, TType.BOOL, 'success', None, None, ), # 0
13424 
  )
13425 
 
13426 
  def __init__(self, success=None,):
13427 
    self.success = success
13428 
 
13429 
  def read(self, iprot):
13430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13432 
      return
13433 
    iprot.readStructBegin()
13434 
    while True:
13435 
      (fname, ftype, fid) = iprot.readFieldBegin()
13436 
      if ftype == TType.STOP:
13437 
        break
13438 
      if fid == 0:
13439 
        if ftype == TType.BOOL:
13440 
          self.success = iprot.readBool();
13441 
        else:
13442 
          iprot.skip(ftype)
13443 
      else:
13444 
        iprot.skip(ftype)
13445 
      iprot.readFieldEnd()
13446 
    iprot.readStructEnd()
13447 
 
13448 
  def write(self, oprot):
13449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13451 
      return
13452 
    oprot.writeStructBegin('deleteTag_result')
13453 
    if self.success is not None:
13454 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13455 
      oprot.writeBool(self.success)
13456 
      oprot.writeFieldEnd()
13457 
    oprot.writeFieldStop()
13458 
    oprot.writeStructEnd()
13459 
 
13460 
  def validate(self):
13461 
    return
13462 
 
13463 
 
13464 
  def __repr__(self):
13465 
    L = ['%s=%r' % (key, value)
13466 
      for key, value in self.__dict__.iteritems()]
13467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13468 
 
13469 
  def __eq__(self, other):
13470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13471 
 
13472 
  def __ne__(self, other):
13473 
    return not (self == other)
13474 
 
13475 
class getAllTags_args:
13476 
 
13477 
  thrift_spec = (
13478 
  )
13479 
 
13480 
  def read(self, iprot):
13481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13483 
      return
13484 
    iprot.readStructBegin()
13485 
    while True:
13486 
      (fname, ftype, fid) = iprot.readFieldBegin()
13487 
      if ftype == TType.STOP:
13488 
        break
13489 
      else:
13490 
        iprot.skip(ftype)
13491 
      iprot.readFieldEnd()
13492 
    iprot.readStructEnd()
13493 
 
13494 
  def write(self, oprot):
13495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13497 
      return
13498 
    oprot.writeStructBegin('getAllTags_args')
13499 
    oprot.writeFieldStop()
13500 
    oprot.writeStructEnd()
13501 
 
13502 
  def validate(self):
13503 
    return
13504 
 
13505 
 
13506 
  def __repr__(self):
13507 
    L = ['%s=%r' % (key, value)
13508 
      for key, value in self.__dict__.iteritems()]
13509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13510 
 
13511 
  def __eq__(self, other):
13512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13513 
 
13514 
  def __ne__(self, other):
13515 
    return not (self == other)
13516 
 
13517 
class getAllTags_result:
13518 
  """
13519 
  Attributes:
13520 
   - success
13521 
  """
13522 
 
13523 
  thrift_spec = (
13524 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13525 
  )
13526 
 
13527 
  def __init__(self, success=None,):
13528 
    self.success = success
13529 
 
13530 
  def read(self, iprot):
13531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13533 
      return
13534 
    iprot.readStructBegin()
13535 
    while True:
13536 
      (fname, ftype, fid) = iprot.readFieldBegin()
13537 
      if ftype == TType.STOP:
13538 
        break
13539 
      if fid == 0:
13540 
        if ftype == TType.LIST:
13541 
          self.success = []
8590 kshitij.so 13542 
          (_etype168, _size165) = iprot.readListBegin()
13543 
          for _i169 in xrange(_size165):
13544 
            _elem170 = iprot.readString();
13545 
            self.success.append(_elem170)
6512 kshitij.so 13546 
          iprot.readListEnd()
13547 
        else:
13548 
          iprot.skip(ftype)
13549 
      else:
13550 
        iprot.skip(ftype)
13551 
      iprot.readFieldEnd()
13552 
    iprot.readStructEnd()
13553 
 
13554 
  def write(self, oprot):
13555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13557 
      return
13558 
    oprot.writeStructBegin('getAllTags_result')
13559 
    if self.success is not None:
13560 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13561 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 13562 
      for iter171 in self.success:
13563 
        oprot.writeString(iter171)
6512 kshitij.so 13564 
      oprot.writeListEnd()
13565 
      oprot.writeFieldEnd()
13566 
    oprot.writeFieldStop()
13567 
    oprot.writeStructEnd()
13568 
 
13569 
  def validate(self):
13570 
    return
13571 
 
13572 
 
13573 
  def __repr__(self):
13574 
    L = ['%s=%r' % (key, value)
13575 
      for key, value in self.__dict__.iteritems()]
13576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13577 
 
13578 
  def __eq__(self, other):
13579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13580 
 
13581 
  def __ne__(self, other):
13582 
    return not (self == other)
13583 
 
13584 
class getAllEntitiesByTagName_args:
13585 
  """
13586 
  Attributes:
13587 
   - displayName
13588 
  """
13589 
 
13590 
  thrift_spec = (
13591 
    None, # 0
13592 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13593 
  )
13594 
 
13595 
  def __init__(self, displayName=None,):
13596 
    self.displayName = displayName
13597 
 
13598 
  def read(self, iprot):
13599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13601 
      return
13602 
    iprot.readStructBegin()
13603 
    while True:
13604 
      (fname, ftype, fid) = iprot.readFieldBegin()
13605 
      if ftype == TType.STOP:
13606 
        break
13607 
      if fid == 1:
13608 
        if ftype == TType.STRING:
13609 
          self.displayName = iprot.readString();
13610 
        else:
13611 
          iprot.skip(ftype)
13612 
      else:
13613 
        iprot.skip(ftype)
13614 
      iprot.readFieldEnd()
13615 
    iprot.readStructEnd()
13616 
 
13617 
  def write(self, oprot):
13618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13620 
      return
13621 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
13622 
    if self.displayName is not None:
13623 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13624 
      oprot.writeString(self.displayName)
13625 
      oprot.writeFieldEnd()
13626 
    oprot.writeFieldStop()
13627 
    oprot.writeStructEnd()
13628 
 
13629 
  def validate(self):
13630 
    return
13631 
 
13632 
 
13633 
  def __repr__(self):
13634 
    L = ['%s=%r' % (key, value)
13635 
      for key, value in self.__dict__.iteritems()]
13636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13637 
 
13638 
  def __eq__(self, other):
13639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13640 
 
13641 
  def __ne__(self, other):
13642 
    return not (self == other)
13643 
 
13644 
class getAllEntitiesByTagName_result:
13645 
  """
13646 
  Attributes:
13647 
   - success
13648 
  """
13649 
 
13650 
  thrift_spec = (
13651 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13652 
  )
13653 
 
13654 
  def __init__(self, success=None,):
13655 
    self.success = success
13656 
 
13657 
  def read(self, iprot):
13658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13660 
      return
13661 
    iprot.readStructBegin()
13662 
    while True:
13663 
      (fname, ftype, fid) = iprot.readFieldBegin()
13664 
      if ftype == TType.STOP:
13665 
        break
13666 
      if fid == 0:
13667 
        if ftype == TType.LIST:
13668 
          self.success = []
8590 kshitij.so 13669 
          (_etype175, _size172) = iprot.readListBegin()
13670 
          for _i176 in xrange(_size172):
13671 
            _elem177 = iprot.readI64();
13672 
            self.success.append(_elem177)
6512 kshitij.so 13673 
          iprot.readListEnd()
13674 
        else:
13675 
          iprot.skip(ftype)
13676 
      else:
13677 
        iprot.skip(ftype)
13678 
      iprot.readFieldEnd()
13679 
    iprot.readStructEnd()
13680 
 
13681 
  def write(self, oprot):
13682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13684 
      return
13685 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
13686 
    if self.success is not None:
13687 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13688 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 13689 
      for iter178 in self.success:
13690 
        oprot.writeI64(iter178)
6512 kshitij.so 13691 
      oprot.writeListEnd()
13692 
      oprot.writeFieldEnd()
13693 
    oprot.writeFieldStop()
13694 
    oprot.writeStructEnd()
13695 
 
13696 
  def validate(self):
13697 
    return
13698 
 
13699 
 
13700 
  def __repr__(self):
13701 
    L = ['%s=%r' % (key, value)
13702 
      for key, value in self.__dict__.iteritems()]
13703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13704 
 
13705 
  def __eq__(self, other):
13706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13707 
 
13708 
  def __ne__(self, other):
13709 
    return not (self == other)
13710 
 
6845 amit.gupta 13711 
class getAllEntityTags_args:
13712 
 
13713 
  thrift_spec = (
13714 
  )
13715 
 
13716 
  def read(self, iprot):
13717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13719 
      return
13720 
    iprot.readStructBegin()
13721 
    while True:
13722 
      (fname, ftype, fid) = iprot.readFieldBegin()
13723 
      if ftype == TType.STOP:
13724 
        break
13725 
      else:
13726 
        iprot.skip(ftype)
13727 
      iprot.readFieldEnd()
13728 
    iprot.readStructEnd()
13729 
 
13730 
  def write(self, oprot):
13731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13733 
      return
13734 
    oprot.writeStructBegin('getAllEntityTags_args')
13735 
    oprot.writeFieldStop()
13736 
    oprot.writeStructEnd()
13737 
 
13738 
  def validate(self):
13739 
    return
13740 
 
13741 
 
13742 
  def __repr__(self):
13743 
    L = ['%s=%r' % (key, value)
13744 
      for key, value in self.__dict__.iteritems()]
13745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13746 
 
13747 
  def __eq__(self, other):
13748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13749 
 
13750 
  def __ne__(self, other):
13751 
    return not (self == other)
13752 
 
13753 
class getAllEntityTags_result:
13754 
  """
13755 
  Attributes:
13756 
   - success
13757 
  """
13758 
 
13759 
  thrift_spec = (
13760 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
13761 
  )
13762 
 
13763 
  def __init__(self, success=None,):
13764 
    self.success = success
13765 
 
13766 
  def read(self, iprot):
13767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13769 
      return
13770 
    iprot.readStructBegin()
13771 
    while True:
13772 
      (fname, ftype, fid) = iprot.readFieldBegin()
13773 
      if ftype == TType.STOP:
13774 
        break
13775 
      if fid == 0:
13776 
        if ftype == TType.MAP:
13777 
          self.success = {}
8590 kshitij.so 13778 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
13779 
          for _i183 in xrange(_size179):
13780 
            _key184 = iprot.readI64();
13781 
            _val185 = []
13782 
            (_etype189, _size186) = iprot.readListBegin()
13783 
            for _i190 in xrange(_size186):
13784 
              _elem191 = iprot.readString();
13785 
              _val185.append(_elem191)
6845 amit.gupta 13786 
            iprot.readListEnd()
8590 kshitij.so 13787 
            self.success[_key184] = _val185
6845 amit.gupta 13788 
          iprot.readMapEnd()
13789 
        else:
13790 
          iprot.skip(ftype)
13791 
      else:
13792 
        iprot.skip(ftype)
13793 
      iprot.readFieldEnd()
13794 
    iprot.readStructEnd()
13795 
 
13796 
  def write(self, oprot):
13797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13799 
      return
13800 
    oprot.writeStructBegin('getAllEntityTags_result')
13801 
    if self.success is not None:
13802 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13803 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 13804 
      for kiter192,viter193 in self.success.items():
13805 
        oprot.writeI64(kiter192)
13806 
        oprot.writeListBegin(TType.STRING, len(viter193))
13807 
        for iter194 in viter193:
13808 
          oprot.writeString(iter194)
6845 amit.gupta 13809 
        oprot.writeListEnd()
13810 
      oprot.writeMapEnd()
13811 
      oprot.writeFieldEnd()
13812 
    oprot.writeFieldStop()
13813 
    oprot.writeStructEnd()
13814 
 
13815 
  def validate(self):
13816 
    return
13817 
 
13818 
 
13819 
  def __repr__(self):
13820 
    L = ['%s=%r' % (key, value)
13821 
      for key, value in self.__dict__.iteritems()]
13822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13823 
 
13824 
  def __eq__(self, other):
13825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13826 
 
13827 
  def __ne__(self, other):
13828 
    return not (self == other)
13829 
 
6850 kshitij.so 13830 
class addBanner_args:
13831 
  """
13832 
  Attributes:
8590 kshitij.so 13833 
   - bannerCongregate
6850 kshitij.so 13834 
  """
13835 
 
13836 
  thrift_spec = (
13837 
    None, # 0
8590 kshitij.so 13838 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 13839 
  )
13840 
 
8590 kshitij.so 13841 
  def __init__(self, bannerCongregate=None,):
13842 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 13843 
 
13844 
  def read(self, iprot):
13845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13847 
      return
13848 
    iprot.readStructBegin()
13849 
    while True:
13850 
      (fname, ftype, fid) = iprot.readFieldBegin()
13851 
      if ftype == TType.STOP:
13852 
        break
13853 
      if fid == 1:
8579 kshitij.so 13854 
        if ftype == TType.STRUCT:
8590 kshitij.so 13855 
          self.bannerCongregate = BannerCongregate()
13856 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 13857 
        else:
13858 
          iprot.skip(ftype)
8579 kshitij.so 13859 
      else:
13860 
        iprot.skip(ftype)
13861 
      iprot.readFieldEnd()
13862 
    iprot.readStructEnd()
13863 
 
13864 
  def write(self, oprot):
13865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13867 
      return
13868 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 13869 
    if self.bannerCongregate is not None:
13870 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
13871 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 13872 
      oprot.writeFieldEnd()
13873 
    oprot.writeFieldStop()
13874 
    oprot.writeStructEnd()
13875 
 
13876 
  def validate(self):
13877 
    return
13878 
 
13879 
 
13880 
  def __repr__(self):
13881 
    L = ['%s=%r' % (key, value)
13882 
      for key, value in self.__dict__.iteritems()]
13883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13884 
 
13885 
  def __eq__(self, other):
13886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13887 
 
13888 
  def __ne__(self, other):
13889 
    return not (self == other)
13890 
 
13891 
class addBanner_result:
10097 kshitij.so 13892 
  """
13893 
  Attributes:
13894 
   - success
13895 
  """
8579 kshitij.so 13896 
 
13897 
  thrift_spec = (
10097 kshitij.so 13898 
    (0, TType.BOOL, 'success', None, None, ), # 0
8579 kshitij.so 13899 
  )
13900 
 
10097 kshitij.so 13901 
  def __init__(self, success=None,):
13902 
    self.success = success
13903 
 
8579 kshitij.so 13904 
  def read(self, iprot):
13905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13907 
      return
13908 
    iprot.readStructBegin()
13909 
    while True:
13910 
      (fname, ftype, fid) = iprot.readFieldBegin()
13911 
      if ftype == TType.STOP:
13912 
        break
10097 kshitij.so 13913 
      if fid == 0:
13914 
        if ftype == TType.BOOL:
13915 
          self.success = iprot.readBool();
13916 
        else:
13917 
          iprot.skip(ftype)
8579 kshitij.so 13918 
      else:
13919 
        iprot.skip(ftype)
13920 
      iprot.readFieldEnd()
13921 
    iprot.readStructEnd()
13922 
 
13923 
  def write(self, oprot):
13924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13926 
      return
13927 
    oprot.writeStructBegin('addBanner_result')
10097 kshitij.so 13928 
    if self.success is not None:
13929 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13930 
      oprot.writeBool(self.success)
13931 
      oprot.writeFieldEnd()
8579 kshitij.so 13932 
    oprot.writeFieldStop()
13933 
    oprot.writeStructEnd()
13934 
 
13935 
  def validate(self):
13936 
    return
13937 
 
13938 
 
13939 
  def __repr__(self):
13940 
    L = ['%s=%r' % (key, value)
13941 
      for key, value in self.__dict__.iteritems()]
13942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13943 
 
13944 
  def __eq__(self, other):
13945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13946 
 
13947 
  def __ne__(self, other):
13948 
    return not (self == other)
13949 
 
13950 
class updateBanner_args:
13951 
  """
13952 
  Attributes:
13953 
   - banner
13954 
  """
13955 
 
13956 
  thrift_spec = (
13957 
    None, # 0
13958 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
13959 
  )
13960 
 
13961 
  def __init__(self, banner=None,):
13962 
    self.banner = banner
13963 
 
13964 
  def read(self, iprot):
13965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13967 
      return
13968 
    iprot.readStructBegin()
13969 
    while True:
13970 
      (fname, ftype, fid) = iprot.readFieldBegin()
13971 
      if ftype == TType.STOP:
13972 
        break
13973 
      if fid == 1:
13974 
        if ftype == TType.STRUCT:
13975 
          self.banner = Banner()
13976 
          self.banner.read(iprot)
6850 kshitij.so 13977 
        else:
13978 
          iprot.skip(ftype)
13979 
      else:
13980 
        iprot.skip(ftype)
13981 
      iprot.readFieldEnd()
13982 
    iprot.readStructEnd()
13983 
 
13984 
  def write(self, oprot):
13985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13987 
      return
8579 kshitij.so 13988 
    oprot.writeStructBegin('updateBanner_args')
13989 
    if self.banner is not None:
13990 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
13991 
      self.banner.write(oprot)
6850 kshitij.so 13992 
      oprot.writeFieldEnd()
13993 
    oprot.writeFieldStop()
13994 
    oprot.writeStructEnd()
13995 
 
13996 
  def validate(self):
13997 
    return
13998 
 
13999 
 
14000 
  def __repr__(self):
14001 
    L = ['%s=%r' % (key, value)
14002 
      for key, value in self.__dict__.iteritems()]
14003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14004 
 
14005 
  def __eq__(self, other):
14006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14007 
 
14008 
  def __ne__(self, other):
14009 
    return not (self == other)
14010 
 
8579 kshitij.so 14011 
class updateBanner_result:
6850 kshitij.so 14012 
  """
14013 
  Attributes:
14014 
   - success
14015 
  """
14016 
 
14017 
  thrift_spec = (
14018 
    (0, TType.BOOL, 'success', None, None, ), # 0
14019 
  )
14020 
 
14021 
  def __init__(self, success=None,):
14022 
    self.success = success
14023 
 
14024 
  def read(self, iprot):
14025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14027 
      return
14028 
    iprot.readStructBegin()
14029 
    while True:
14030 
      (fname, ftype, fid) = iprot.readFieldBegin()
14031 
      if ftype == TType.STOP:
14032 
        break
14033 
      if fid == 0:
14034 
        if ftype == TType.BOOL:
14035 
          self.success = iprot.readBool();
14036 
        else:
14037 
          iprot.skip(ftype)
14038 
      else:
14039 
        iprot.skip(ftype)
14040 
      iprot.readFieldEnd()
14041 
    iprot.readStructEnd()
14042 
 
14043 
  def write(self, oprot):
14044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14046 
      return
8579 kshitij.so 14047 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 14048 
    if self.success is not None:
14049 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14050 
      oprot.writeBool(self.success)
14051 
      oprot.writeFieldEnd()
14052 
    oprot.writeFieldStop()
14053 
    oprot.writeStructEnd()
14054 
 
14055 
  def validate(self):
14056 
    return
14057 
 
14058 
 
14059 
  def __repr__(self):
14060 
    L = ['%s=%r' % (key, value)
14061 
      for key, value in self.__dict__.iteritems()]
14062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14063 
 
14064 
  def __eq__(self, other):
14065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14066 
 
14067 
  def __ne__(self, other):
14068 
    return not (self == other)
14069 
 
14070 
class getAllBanners_args:
14071 
 
14072 
  thrift_spec = (
14073 
  )
14074 
 
14075 
  def read(self, iprot):
14076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14078 
      return
14079 
    iprot.readStructBegin()
14080 
    while True:
14081 
      (fname, ftype, fid) = iprot.readFieldBegin()
14082 
      if ftype == TType.STOP:
14083 
        break
14084 
      else:
14085 
        iprot.skip(ftype)
14086 
      iprot.readFieldEnd()
14087 
    iprot.readStructEnd()
14088 
 
14089 
  def write(self, oprot):
14090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14092 
      return
14093 
    oprot.writeStructBegin('getAllBanners_args')
14094 
    oprot.writeFieldStop()
14095 
    oprot.writeStructEnd()
14096 
 
14097 
  def validate(self):
14098 
    return
14099 
 
14100 
 
14101 
  def __repr__(self):
14102 
    L = ['%s=%r' % (key, value)
14103 
      for key, value in self.__dict__.iteritems()]
14104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14105 
 
14106 
  def __eq__(self, other):
14107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14108 
 
14109 
  def __ne__(self, other):
14110 
    return not (self == other)
14111 
 
14112 
class getAllBanners_result:
14113 
  """
14114 
  Attributes:
14115 
   - success
14116 
  """
14117 
 
14118 
  thrift_spec = (
8579 kshitij.so 14119 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 14120 
  )
14121 
 
14122 
  def __init__(self, success=None,):
14123 
    self.success = success
14124 
 
14125 
  def read(self, iprot):
14126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14128 
      return
14129 
    iprot.readStructBegin()
14130 
    while True:
14131 
      (fname, ftype, fid) = iprot.readFieldBegin()
14132 
      if ftype == TType.STOP:
14133 
        break
14134 
      if fid == 0:
14135 
        if ftype == TType.LIST:
14136 
          self.success = []
8590 kshitij.so 14137 
          (_etype198, _size195) = iprot.readListBegin()
14138 
          for _i199 in xrange(_size195):
14139 
            _elem200 = Banner()
14140 
            _elem200.read(iprot)
14141 
            self.success.append(_elem200)
6850 kshitij.so 14142 
          iprot.readListEnd()
14143 
        else:
14144 
          iprot.skip(ftype)
14145 
      else:
14146 
        iprot.skip(ftype)
14147 
      iprot.readFieldEnd()
14148 
    iprot.readStructEnd()
14149 
 
14150 
  def write(self, oprot):
14151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14153 
      return
14154 
    oprot.writeStructBegin('getAllBanners_result')
14155 
    if self.success is not None:
14156 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 14157 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14158 
      for iter201 in self.success:
14159 
        iter201.write(oprot)
6850 kshitij.so 14160 
      oprot.writeListEnd()
14161 
      oprot.writeFieldEnd()
14162 
    oprot.writeFieldStop()
14163 
    oprot.writeStructEnd()
14164 
 
14165 
  def validate(self):
14166 
    return
14167 
 
14168 
 
14169 
  def __repr__(self):
14170 
    L = ['%s=%r' % (key, value)
14171 
      for key, value in self.__dict__.iteritems()]
14172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14173 
 
14174 
  def __eq__(self, other):
14175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14176 
 
14177 
  def __ne__(self, other):
14178 
    return not (self == other)
14179 
 
14180 
class deleteBanner_args:
14181 
  """
14182 
  Attributes:
14183 
   - bannerName
9155 kshitij.so 14184 
   - bannerType
6850 kshitij.so 14185 
  """
14186 
 
14187 
  thrift_spec = (
14188 
    None, # 0
14189 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14190 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 14191 
  )
14192 
 
9155 kshitij.so 14193 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 14194 
    self.bannerName = bannerName
9155 kshitij.so 14195 
    self.bannerType = bannerType
6850 kshitij.so 14196 
 
14197 
  def read(self, iprot):
14198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14200 
      return
14201 
    iprot.readStructBegin()
14202 
    while True:
14203 
      (fname, ftype, fid) = iprot.readFieldBegin()
14204 
      if ftype == TType.STOP:
14205 
        break
14206 
      if fid == 1:
14207 
        if ftype == TType.STRING:
14208 
          self.bannerName = iprot.readString();
14209 
        else:
14210 
          iprot.skip(ftype)
9155 kshitij.so 14211 
      elif fid == 2:
14212 
        if ftype == TType.I32:
14213 
          self.bannerType = iprot.readI32();
14214 
        else:
14215 
          iprot.skip(ftype)
6850 kshitij.so 14216 
      else:
14217 
        iprot.skip(ftype)
14218 
      iprot.readFieldEnd()
14219 
    iprot.readStructEnd()
14220 
 
14221 
  def write(self, oprot):
14222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14224 
      return
14225 
    oprot.writeStructBegin('deleteBanner_args')
14226 
    if self.bannerName is not None:
14227 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14228 
      oprot.writeString(self.bannerName)
14229 
      oprot.writeFieldEnd()
9155 kshitij.so 14230 
    if self.bannerType is not None:
14231 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14232 
      oprot.writeI32(self.bannerType)
14233 
      oprot.writeFieldEnd()
6850 kshitij.so 14234 
    oprot.writeFieldStop()
14235 
    oprot.writeStructEnd()
14236 
 
14237 
  def validate(self):
14238 
    return
14239 
 
14240 
 
14241 
  def __repr__(self):
14242 
    L = ['%s=%r' % (key, value)
14243 
      for key, value in self.__dict__.iteritems()]
14244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14245 
 
14246 
  def __eq__(self, other):
14247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14248 
 
14249 
  def __ne__(self, other):
14250 
    return not (self == other)
14251 
 
14252 
class deleteBanner_result:
14253 
  """
14254 
  Attributes:
14255 
   - success
14256 
  """
14257 
 
14258 
  thrift_spec = (
14259 
    (0, TType.BOOL, 'success', None, None, ), # 0
14260 
  )
14261 
 
14262 
  def __init__(self, success=None,):
14263 
    self.success = success
14264 
 
14265 
  def read(self, iprot):
14266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14268 
      return
14269 
    iprot.readStructBegin()
14270 
    while True:
14271 
      (fname, ftype, fid) = iprot.readFieldBegin()
14272 
      if ftype == TType.STOP:
14273 
        break
14274 
      if fid == 0:
14275 
        if ftype == TType.BOOL:
14276 
          self.success = iprot.readBool();
14277 
        else:
14278 
          iprot.skip(ftype)
14279 
      else:
14280 
        iprot.skip(ftype)
14281 
      iprot.readFieldEnd()
14282 
    iprot.readStructEnd()
14283 
 
14284 
  def write(self, oprot):
14285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14287 
      return
14288 
    oprot.writeStructBegin('deleteBanner_result')
14289 
    if self.success is not None:
14290 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14291 
      oprot.writeBool(self.success)
14292 
      oprot.writeFieldEnd()
14293 
    oprot.writeFieldStop()
14294 
    oprot.writeStructEnd()
14295 
 
14296 
  def validate(self):
14297 
    return
14298 
 
14299 
 
14300 
  def __repr__(self):
14301 
    L = ['%s=%r' % (key, value)
14302 
      for key, value in self.__dict__.iteritems()]
14303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14304 
 
14305 
  def __eq__(self, other):
14306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14307 
 
14308 
  def __ne__(self, other):
14309 
    return not (self == other)
14310 
 
14311 
class getBannerDetails_args:
14312 
  """
14313 
  Attributes:
14314 
   - bannerName
9155 kshitij.so 14315 
   - bannerType
6850 kshitij.so 14316 
  """
14317 
 
14318 
  thrift_spec = (
14319 
    None, # 0
14320 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14321 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 14322 
  )
14323 
 
9155 kshitij.so 14324 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 14325 
    self.bannerName = bannerName
9155 kshitij.so 14326 
    self.bannerType = bannerType
6850 kshitij.so 14327 
 
14328 
  def read(self, iprot):
14329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14331 
      return
14332 
    iprot.readStructBegin()
14333 
    while True:
14334 
      (fname, ftype, fid) = iprot.readFieldBegin()
14335 
      if ftype == TType.STOP:
14336 
        break
14337 
      if fid == 1:
14338 
        if ftype == TType.STRING:
14339 
          self.bannerName = iprot.readString();
14340 
        else:
14341 
          iprot.skip(ftype)
9155 kshitij.so 14342 
      elif fid == 2:
14343 
        if ftype == TType.I32:
14344 
          self.bannerType = iprot.readI32();
14345 
        else:
14346 
          iprot.skip(ftype)
6850 kshitij.so 14347 
      else:
14348 
        iprot.skip(ftype)
14349 
      iprot.readFieldEnd()
14350 
    iprot.readStructEnd()
14351 
 
14352 
  def write(self, oprot):
14353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14355 
      return
14356 
    oprot.writeStructBegin('getBannerDetails_args')
14357 
    if self.bannerName is not None:
14358 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14359 
      oprot.writeString(self.bannerName)
14360 
      oprot.writeFieldEnd()
9155 kshitij.so 14361 
    if self.bannerType is not None:
14362 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14363 
      oprot.writeI32(self.bannerType)
14364 
      oprot.writeFieldEnd()
6850 kshitij.so 14365 
    oprot.writeFieldStop()
14366 
    oprot.writeStructEnd()
14367 
 
14368 
  def validate(self):
14369 
    return
14370 
 
14371 
 
14372 
  def __repr__(self):
14373 
    L = ['%s=%r' % (key, value)
14374 
      for key, value in self.__dict__.iteritems()]
14375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14376 
 
14377 
  def __eq__(self, other):
14378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14379 
 
14380 
  def __ne__(self, other):
14381 
    return not (self == other)
14382 
 
14383 
class getBannerDetails_result:
14384 
  """
14385 
  Attributes:
14386 
   - success
14387 
  """
14388 
 
14389 
  thrift_spec = (
14390 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
14391 
  )
14392 
 
14393 
  def __init__(self, success=None,):
14394 
    self.success = success
14395 
 
14396 
  def read(self, iprot):
14397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14399 
      return
14400 
    iprot.readStructBegin()
14401 
    while True:
14402 
      (fname, ftype, fid) = iprot.readFieldBegin()
14403 
      if ftype == TType.STOP:
14404 
        break
14405 
      if fid == 0:
14406 
        if ftype == TType.STRUCT:
14407 
          self.success = Banner()
14408 
          self.success.read(iprot)
14409 
        else:
14410 
          iprot.skip(ftype)
14411 
      else:
14412 
        iprot.skip(ftype)
14413 
      iprot.readFieldEnd()
14414 
    iprot.readStructEnd()
14415 
 
14416 
  def write(self, oprot):
14417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14419 
      return
14420 
    oprot.writeStructBegin('getBannerDetails_result')
14421 
    if self.success is not None:
14422 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14423 
      self.success.write(oprot)
14424 
      oprot.writeFieldEnd()
14425 
    oprot.writeFieldStop()
14426 
    oprot.writeStructEnd()
14427 
 
14428 
  def validate(self):
14429 
    return
14430 
 
14431 
 
14432 
  def __repr__(self):
14433 
    L = ['%s=%r' % (key, value)
14434 
      for key, value in self.__dict__.iteritems()]
14435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14436 
 
14437 
  def __eq__(self, other):
14438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14439 
 
14440 
  def __ne__(self, other):
14441 
    return not (self == other)
14442 
 
14443 
class getActiveBanners_args:
14444 
 
14445 
  thrift_spec = (
14446 
  )
14447 
 
14448 
  def read(self, iprot):
14449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14451 
      return
14452 
    iprot.readStructBegin()
14453 
    while True:
14454 
      (fname, ftype, fid) = iprot.readFieldBegin()
14455 
      if ftype == TType.STOP:
14456 
        break
14457 
      else:
14458 
        iprot.skip(ftype)
14459 
      iprot.readFieldEnd()
14460 
    iprot.readStructEnd()
14461 
 
14462 
  def write(self, oprot):
14463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14465 
      return
14466 
    oprot.writeStructBegin('getActiveBanners_args')
14467 
    oprot.writeFieldStop()
14468 
    oprot.writeStructEnd()
14469 
 
14470 
  def validate(self):
14471 
    return
14472 
 
14473 
 
14474 
  def __repr__(self):
14475 
    L = ['%s=%r' % (key, value)
14476 
      for key, value in self.__dict__.iteritems()]
14477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14478 
 
14479 
  def __eq__(self, other):
14480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14481 
 
14482 
  def __ne__(self, other):
14483 
    return not (self == other)
14484 
 
14485 
class getActiveBanners_result:
14486 
  """
14487 
  Attributes:
14488 
   - success
14489 
  """
14490 
 
14491 
  thrift_spec = (
8579 kshitij.so 14492 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 14493 
  )
14494 
 
14495 
  def __init__(self, success=None,):
14496 
    self.success = success
14497 
 
14498 
  def read(self, iprot):
14499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14501 
      return
14502 
    iprot.readStructBegin()
14503 
    while True:
14504 
      (fname, ftype, fid) = iprot.readFieldBegin()
14505 
      if ftype == TType.STOP:
14506 
        break
14507 
      if fid == 0:
8579 kshitij.so 14508 
        if ftype == TType.MAP:
14509 
          self.success = {}
8590 kshitij.so 14510 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
14511 
          for _i206 in xrange(_size202):
14512 
            _key207 = iprot.readString();
14513 
            _val208 = []
14514 
            (_etype212, _size209) = iprot.readListBegin()
14515 
            for _i213 in xrange(_size209):
14516 
              _elem214 = Banner()
14517 
              _elem214.read(iprot)
14518 
              _val208.append(_elem214)
8579 kshitij.so 14519 
            iprot.readListEnd()
8590 kshitij.so 14520 
            self.success[_key207] = _val208
8579 kshitij.so 14521 
          iprot.readMapEnd()
6850 kshitij.so 14522 
        else:
14523 
          iprot.skip(ftype)
14524 
      else:
14525 
        iprot.skip(ftype)
14526 
      iprot.readFieldEnd()
14527 
    iprot.readStructEnd()
14528 
 
14529 
  def write(self, oprot):
14530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14532 
      return
14533 
    oprot.writeStructBegin('getActiveBanners_result')
14534 
    if self.success is not None:
8579 kshitij.so 14535 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14536 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 14537 
      for kiter215,viter216 in self.success.items():
14538 
        oprot.writeString(kiter215)
14539 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
14540 
        for iter217 in viter216:
14541 
          iter217.write(oprot)
8579 kshitij.so 14542 
        oprot.writeListEnd()
14543 
      oprot.writeMapEnd()
6850 kshitij.so 14544 
      oprot.writeFieldEnd()
14545 
    oprot.writeFieldStop()
14546 
    oprot.writeStructEnd()
14547 
 
14548 
  def validate(self):
14549 
    return
14550 
 
14551 
 
14552 
  def __repr__(self):
14553 
    L = ['%s=%r' % (key, value)
14554 
      for key, value in self.__dict__.iteritems()]
14555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14556 
 
14557 
  def __eq__(self, other):
14558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14559 
 
14560 
  def __ne__(self, other):
14561 
    return not (self == other)
14562 
 
6849 kshitij.so 14563 
class addBannerMap_args:
14564 
  """
14565 
  Attributes:
8579 kshitij.so 14566 
   - bannerMaps
6849 kshitij.so 14567 
  """
14568 
 
14569 
  thrift_spec = (
14570 
    None, # 0
8579 kshitij.so 14571 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 14572 
  )
14573 
 
8579 kshitij.so 14574 
  def __init__(self, bannerMaps=None,):
14575 
    self.bannerMaps = bannerMaps
6849 kshitij.so 14576 
 
14577 
  def read(self, iprot):
14578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14580 
      return
14581 
    iprot.readStructBegin()
14582 
    while True:
14583 
      (fname, ftype, fid) = iprot.readFieldBegin()
14584 
      if ftype == TType.STOP:
14585 
        break
14586 
      if fid == 1:
8579 kshitij.so 14587 
        if ftype == TType.LIST:
14588 
          self.bannerMaps = []
8590 kshitij.so 14589 
          (_etype221, _size218) = iprot.readListBegin()
14590 
          for _i222 in xrange(_size218):
14591 
            _elem223 = BannerMap()
14592 
            _elem223.read(iprot)
14593 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 14594 
          iprot.readListEnd()
6849 kshitij.so 14595 
        else:
14596 
          iprot.skip(ftype)
8579 kshitij.so 14597 
      else:
14598 
        iprot.skip(ftype)
14599 
      iprot.readFieldEnd()
14600 
    iprot.readStructEnd()
14601 
 
14602 
  def write(self, oprot):
14603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14605 
      return
14606 
    oprot.writeStructBegin('addBannerMap_args')
14607 
    if self.bannerMaps is not None:
14608 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
14609 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 14610 
      for iter224 in self.bannerMaps:
14611 
        iter224.write(oprot)
8579 kshitij.so 14612 
      oprot.writeListEnd()
14613 
      oprot.writeFieldEnd()
14614 
    oprot.writeFieldStop()
14615 
    oprot.writeStructEnd()
14616 
 
14617 
  def validate(self):
14618 
    return
14619 
 
14620 
 
14621 
  def __repr__(self):
14622 
    L = ['%s=%r' % (key, value)
14623 
      for key, value in self.__dict__.iteritems()]
14624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14625 
 
14626 
  def __eq__(self, other):
14627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14628 
 
14629 
  def __ne__(self, other):
14630 
    return not (self == other)
14631 
 
14632 
class addBannerMap_result:
14633 
  """
14634 
  Attributes:
14635 
   - success
14636 
  """
14637 
 
14638 
  thrift_spec = (
14639 
    (0, TType.BOOL, 'success', None, None, ), # 0
14640 
  )
14641 
 
14642 
  def __init__(self, success=None,):
14643 
    self.success = success
14644 
 
14645 
  def read(self, iprot):
14646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14648 
      return
14649 
    iprot.readStructBegin()
14650 
    while True:
14651 
      (fname, ftype, fid) = iprot.readFieldBegin()
14652 
      if ftype == TType.STOP:
14653 
        break
14654 
      if fid == 0:
14655 
        if ftype == TType.BOOL:
14656 
          self.success = iprot.readBool();
6849 kshitij.so 14657 
        else:
14658 
          iprot.skip(ftype)
8579 kshitij.so 14659 
      else:
14660 
        iprot.skip(ftype)
14661 
      iprot.readFieldEnd()
14662 
    iprot.readStructEnd()
14663 
 
14664 
  def write(self, oprot):
14665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14667 
      return
14668 
    oprot.writeStructBegin('addBannerMap_result')
14669 
    if self.success is not None:
14670 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14671 
      oprot.writeBool(self.success)
14672 
      oprot.writeFieldEnd()
14673 
    oprot.writeFieldStop()
14674 
    oprot.writeStructEnd()
14675 
 
14676 
  def validate(self):
14677 
    return
14678 
 
14679 
 
14680 
  def __repr__(self):
14681 
    L = ['%s=%r' % (key, value)
14682 
      for key, value in self.__dict__.iteritems()]
14683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14684 
 
14685 
  def __eq__(self, other):
14686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14687 
 
14688 
  def __ne__(self, other):
14689 
    return not (self == other)
14690 
 
14691 
class updateBannerMap_args:
14692 
  """
14693 
  Attributes:
14694 
   - bannerMap
14695 
  """
14696 
 
14697 
  thrift_spec = (
14698 
    None, # 0
14699 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
14700 
  )
14701 
 
14702 
  def __init__(self, bannerMap=None,):
14703 
    self.bannerMap = bannerMap
14704 
 
14705 
  def read(self, iprot):
14706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14708 
      return
14709 
    iprot.readStructBegin()
14710 
    while True:
14711 
      (fname, ftype, fid) = iprot.readFieldBegin()
14712 
      if ftype == TType.STOP:
14713 
        break
14714 
      if fid == 1:
14715 
        if ftype == TType.STRUCT:
14716 
          self.bannerMap = BannerMap()
14717 
          self.bannerMap.read(iprot)
6849 kshitij.so 14718 
        else:
14719 
          iprot.skip(ftype)
14720 
      else:
14721 
        iprot.skip(ftype)
14722 
      iprot.readFieldEnd()
14723 
    iprot.readStructEnd()
14724 
 
14725 
  def write(self, oprot):
14726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14728 
      return
8579 kshitij.so 14729 
    oprot.writeStructBegin('updateBannerMap_args')
14730 
    if self.bannerMap is not None:
14731 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
14732 
      self.bannerMap.write(oprot)
6849 kshitij.so 14733 
      oprot.writeFieldEnd()
14734 
    oprot.writeFieldStop()
14735 
    oprot.writeStructEnd()
14736 
 
14737 
  def validate(self):
14738 
    return
14739 
 
14740 
 
14741 
  def __repr__(self):
14742 
    L = ['%s=%r' % (key, value)
14743 
      for key, value in self.__dict__.iteritems()]
14744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14745 
 
14746 
  def __eq__(self, other):
14747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14748 
 
14749 
  def __ne__(self, other):
14750 
    return not (self == other)
14751 
 
8579 kshitij.so 14752 
class updateBannerMap_result:
6849 kshitij.so 14753 
  """
14754 
  Attributes:
14755 
   - success
14756 
  """
14757 
 
14758 
  thrift_spec = (
14759 
    (0, TType.BOOL, 'success', None, None, ), # 0
14760 
  )
14761 
 
14762 
  def __init__(self, success=None,):
14763 
    self.success = success
14764 
 
14765 
  def read(self, iprot):
14766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14768 
      return
14769 
    iprot.readStructBegin()
14770 
    while True:
14771 
      (fname, ftype, fid) = iprot.readFieldBegin()
14772 
      if ftype == TType.STOP:
14773 
        break
14774 
      if fid == 0:
14775 
        if ftype == TType.BOOL:
14776 
          self.success = iprot.readBool();
14777 
        else:
14778 
          iprot.skip(ftype)
14779 
      else:
14780 
        iprot.skip(ftype)
14781 
      iprot.readFieldEnd()
14782 
    iprot.readStructEnd()
14783 
 
14784 
  def write(self, oprot):
14785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14787 
      return
8579 kshitij.so 14788 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 14789 
    if self.success is not None:
14790 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14791 
      oprot.writeBool(self.success)
14792 
      oprot.writeFieldEnd()
14793 
    oprot.writeFieldStop()
14794 
    oprot.writeStructEnd()
14795 
 
14796 
  def validate(self):
14797 
    return
14798 
 
14799 
 
14800 
  def __repr__(self):
14801 
    L = ['%s=%r' % (key, value)
14802 
      for key, value in self.__dict__.iteritems()]
14803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14804 
 
14805 
  def __eq__(self, other):
14806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14807 
 
14808 
  def __ne__(self, other):
14809 
    return not (self == other)
14810 
 
14811 
class deleteBannerMap_args:
14812 
  """
14813 
  Attributes:
14814 
   - bannerName
14815 
  """
14816 
 
14817 
  thrift_spec = (
14818 
    None, # 0
14819 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
14820 
  )
14821 
 
14822 
  def __init__(self, bannerName=None,):
14823 
    self.bannerName = bannerName
14824 
 
14825 
  def read(self, iprot):
14826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14828 
      return
14829 
    iprot.readStructBegin()
14830 
    while True:
14831 
      (fname, ftype, fid) = iprot.readFieldBegin()
14832 
      if ftype == TType.STOP:
14833 
        break
14834 
      if fid == 1:
14835 
        if ftype == TType.STRING:
14836 
          self.bannerName = iprot.readString();
14837 
        else:
14838 
          iprot.skip(ftype)
14839 
      else:
14840 
        iprot.skip(ftype)
14841 
      iprot.readFieldEnd()
14842 
    iprot.readStructEnd()
14843 
 
14844 
  def write(self, oprot):
14845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14847 
      return
14848 
    oprot.writeStructBegin('deleteBannerMap_args')
14849 
    if self.bannerName is not None:
14850 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14851 
      oprot.writeString(self.bannerName)
14852 
      oprot.writeFieldEnd()
14853 
    oprot.writeFieldStop()
14854 
    oprot.writeStructEnd()
14855 
 
14856 
  def validate(self):
14857 
    return
14858 
 
14859 
 
14860 
  def __repr__(self):
14861 
    L = ['%s=%r' % (key, value)
14862 
      for key, value in self.__dict__.iteritems()]
14863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14864 
 
14865 
  def __eq__(self, other):
14866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14867 
 
14868 
  def __ne__(self, other):
14869 
    return not (self == other)
14870 
 
14871 
class deleteBannerMap_result:
14872 
  """
14873 
  Attributes:
14874 
   - success
14875 
  """
14876 
 
14877 
  thrift_spec = (
14878 
    (0, TType.BOOL, 'success', None, None, ), # 0
14879 
  )
14880 
 
14881 
  def __init__(self, success=None,):
14882 
    self.success = success
14883 
 
14884 
  def read(self, iprot):
14885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14887 
      return
14888 
    iprot.readStructBegin()
14889 
    while True:
14890 
      (fname, ftype, fid) = iprot.readFieldBegin()
14891 
      if ftype == TType.STOP:
14892 
        break
14893 
      if fid == 0:
14894 
        if ftype == TType.BOOL:
14895 
          self.success = iprot.readBool();
14896 
        else:
14897 
          iprot.skip(ftype)
14898 
      else:
14899 
        iprot.skip(ftype)
14900 
      iprot.readFieldEnd()
14901 
    iprot.readStructEnd()
14902 
 
14903 
  def write(self, oprot):
14904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14906 
      return
14907 
    oprot.writeStructBegin('deleteBannerMap_result')
14908 
    if self.success is not None:
14909 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14910 
      oprot.writeBool(self.success)
14911 
      oprot.writeFieldEnd()
14912 
    oprot.writeFieldStop()
14913 
    oprot.writeStructEnd()
14914 
 
14915 
  def validate(self):
14916 
    return
14917 
 
14918 
 
14919 
  def __repr__(self):
14920 
    L = ['%s=%r' % (key, value)
14921 
      for key, value in self.__dict__.iteritems()]
14922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14923 
 
14924 
  def __eq__(self, other):
14925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14926 
 
14927 
  def __ne__(self, other):
14928 
    return not (self == other)
14929 
 
14930 
class getBannerMapDetails_args:
14931 
  """
14932 
  Attributes:
14933 
   - bannerName
9155 kshitij.so 14934 
   - bannerType
6849 kshitij.so 14935 
  """
14936 
 
14937 
  thrift_spec = (
14938 
    None, # 0
14939 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14940 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 14941 
  )
14942 
 
9155 kshitij.so 14943 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 14944 
    self.bannerName = bannerName
9155 kshitij.so 14945 
    self.bannerType = bannerType
6849 kshitij.so 14946 
 
14947 
  def read(self, iprot):
14948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14950 
      return
14951 
    iprot.readStructBegin()
14952 
    while True:
14953 
      (fname, ftype, fid) = iprot.readFieldBegin()
14954 
      if ftype == TType.STOP:
14955 
        break
14956 
      if fid == 1:
14957 
        if ftype == TType.STRING:
14958 
          self.bannerName = iprot.readString();
14959 
        else:
14960 
          iprot.skip(ftype)
9155 kshitij.so 14961 
      elif fid == 2:
14962 
        if ftype == TType.I32:
14963 
          self.bannerType = iprot.readI32();
14964 
        else:
14965 
          iprot.skip(ftype)
6849 kshitij.so 14966 
      else:
14967 
        iprot.skip(ftype)
14968 
      iprot.readFieldEnd()
14969 
    iprot.readStructEnd()
14970 
 
14971 
  def write(self, oprot):
14972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14974 
      return
14975 
    oprot.writeStructBegin('getBannerMapDetails_args')
14976 
    if self.bannerName is not None:
14977 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14978 
      oprot.writeString(self.bannerName)
14979 
      oprot.writeFieldEnd()
9155 kshitij.so 14980 
    if self.bannerType is not None:
14981 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14982 
      oprot.writeI32(self.bannerType)
14983 
      oprot.writeFieldEnd()
6849 kshitij.so 14984 
    oprot.writeFieldStop()
14985 
    oprot.writeStructEnd()
14986 
 
14987 
  def validate(self):
14988 
    return
14989 
 
14990 
 
14991 
  def __repr__(self):
14992 
    L = ['%s=%r' % (key, value)
14993 
      for key, value in self.__dict__.iteritems()]
14994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14995 
 
14996 
  def __eq__(self, other):
14997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14998 
 
14999 
  def __ne__(self, other):
15000 
    return not (self == other)
15001 
 
15002 
class getBannerMapDetails_result:
15003 
  """
15004 
  Attributes:
15005 
   - success
15006 
  """
15007 
 
15008 
  thrift_spec = (
15009 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
15010 
  )
15011 
 
15012 
  def __init__(self, success=None,):
15013 
    self.success = success
15014 
 
15015 
  def read(self, iprot):
15016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15018 
      return
15019 
    iprot.readStructBegin()
15020 
    while True:
15021 
      (fname, ftype, fid) = iprot.readFieldBegin()
15022 
      if ftype == TType.STOP:
15023 
        break
15024 
      if fid == 0:
15025 
        if ftype == TType.LIST:
15026 
          self.success = []
8590 kshitij.so 15027 
          (_etype228, _size225) = iprot.readListBegin()
15028 
          for _i229 in xrange(_size225):
15029 
            _elem230 = BannerMap()
15030 
            _elem230.read(iprot)
15031 
            self.success.append(_elem230)
6849 kshitij.so 15032 
          iprot.readListEnd()
15033 
        else:
15034 
          iprot.skip(ftype)
15035 
      else:
15036 
        iprot.skip(ftype)
15037 
      iprot.readFieldEnd()
15038 
    iprot.readStructEnd()
15039 
 
15040 
  def write(self, oprot):
15041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15043 
      return
15044 
    oprot.writeStructBegin('getBannerMapDetails_result')
15045 
    if self.success is not None:
15046 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15047 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15048 
      for iter231 in self.success:
15049 
        iter231.write(oprot)
6849 kshitij.so 15050 
      oprot.writeListEnd()
15051 
      oprot.writeFieldEnd()
15052 
    oprot.writeFieldStop()
15053 
    oprot.writeStructEnd()
15054 
 
15055 
  def validate(self):
15056 
    return
15057 
 
15058 
 
15059 
  def __repr__(self):
15060 
    L = ['%s=%r' % (key, value)
15061 
      for key, value in self.__dict__.iteritems()]
15062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15063 
 
15064 
  def __eq__(self, other):
15065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15066 
 
15067 
  def __ne__(self, other):
15068 
    return not (self == other)
15069 
 
8579 kshitij.so 15070 
class addBannerUri_args:
15071 
  """
15072 
  Attributes:
15073 
   - bannerUriMappings
15074 
  """
15075 
 
15076 
  thrift_spec = (
15077 
    None, # 0
15078 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
15079 
  )
15080 
 
15081 
  def __init__(self, bannerUriMappings=None,):
15082 
    self.bannerUriMappings = bannerUriMappings
15083 
 
15084 
  def read(self, iprot):
15085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15087 
      return
15088 
    iprot.readStructBegin()
15089 
    while True:
15090 
      (fname, ftype, fid) = iprot.readFieldBegin()
15091 
      if ftype == TType.STOP:
15092 
        break
15093 
      if fid == 1:
15094 
        if ftype == TType.LIST:
15095 
          self.bannerUriMappings = []
8590 kshitij.so 15096 
          (_etype235, _size232) = iprot.readListBegin()
15097 
          for _i236 in xrange(_size232):
15098 
            _elem237 = BannerUriMapping()
15099 
            _elem237.read(iprot)
15100 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 15101 
          iprot.readListEnd()
15102 
        else:
15103 
          iprot.skip(ftype)
15104 
      else:
15105 
        iprot.skip(ftype)
15106 
      iprot.readFieldEnd()
15107 
    iprot.readStructEnd()
15108 
 
15109 
  def write(self, oprot):
15110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15112 
      return
15113 
    oprot.writeStructBegin('addBannerUri_args')
15114 
    if self.bannerUriMappings is not None:
15115 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
15116 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 15117 
      for iter238 in self.bannerUriMappings:
15118 
        iter238.write(oprot)
8579 kshitij.so 15119 
      oprot.writeListEnd()
15120 
      oprot.writeFieldEnd()
15121 
    oprot.writeFieldStop()
15122 
    oprot.writeStructEnd()
15123 
 
15124 
  def validate(self):
15125 
    return
15126 
 
15127 
 
15128 
  def __repr__(self):
15129 
    L = ['%s=%r' % (key, value)
15130 
      for key, value in self.__dict__.iteritems()]
15131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15132 
 
15133 
  def __eq__(self, other):
15134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15135 
 
15136 
  def __ne__(self, other):
15137 
    return not (self == other)
15138 
 
15139 
class addBannerUri_result:
15140 
 
15141 
  thrift_spec = (
15142 
  )
15143 
 
15144 
  def read(self, iprot):
15145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15147 
      return
15148 
    iprot.readStructBegin()
15149 
    while True:
15150 
      (fname, ftype, fid) = iprot.readFieldBegin()
15151 
      if ftype == TType.STOP:
15152 
        break
15153 
      else:
15154 
        iprot.skip(ftype)
15155 
      iprot.readFieldEnd()
15156 
    iprot.readStructEnd()
15157 
 
15158 
  def write(self, oprot):
15159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15161 
      return
15162 
    oprot.writeStructBegin('addBannerUri_result')
15163 
    oprot.writeFieldStop()
15164 
    oprot.writeStructEnd()
15165 
 
15166 
  def validate(self):
15167 
    return
15168 
 
15169 
 
15170 
  def __repr__(self):
15171 
    L = ['%s=%r' % (key, value)
15172 
      for key, value in self.__dict__.iteritems()]
15173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15174 
 
15175 
  def __eq__(self, other):
15176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15177 
 
15178 
  def __ne__(self, other):
15179 
    return not (self == other)
15180 
 
15181 
class getUriMapping_args:
15182 
  """
15183 
  Attributes:
15184 
   - bannerName
9155 kshitij.so 15185 
   - bannerType
8579 kshitij.so 15186 
  """
15187 
 
15188 
  thrift_spec = (
15189 
    None, # 0
15190 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 15191 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 15192 
  )
15193 
 
9155 kshitij.so 15194 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 15195 
    self.bannerName = bannerName
9155 kshitij.so 15196 
    self.bannerType = bannerType
8579 kshitij.so 15197 
 
15198 
  def read(self, iprot):
15199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15201 
      return
15202 
    iprot.readStructBegin()
15203 
    while True:
15204 
      (fname, ftype, fid) = iprot.readFieldBegin()
15205 
      if ftype == TType.STOP:
15206 
        break
15207 
      if fid == 1:
15208 
        if ftype == TType.STRING:
15209 
          self.bannerName = iprot.readString();
15210 
        else:
15211 
          iprot.skip(ftype)
9155 kshitij.so 15212 
      elif fid == 2:
15213 
        if ftype == TType.I32:
15214 
          self.bannerType = iprot.readI32();
15215 
        else:
15216 
          iprot.skip(ftype)
8579 kshitij.so 15217 
      else:
15218 
        iprot.skip(ftype)
15219 
      iprot.readFieldEnd()
15220 
    iprot.readStructEnd()
15221 
 
15222 
  def write(self, oprot):
15223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15225 
      return
15226 
    oprot.writeStructBegin('getUriMapping_args')
15227 
    if self.bannerName is not None:
15228 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
15229 
      oprot.writeString(self.bannerName)
15230 
      oprot.writeFieldEnd()
9155 kshitij.so 15231 
    if self.bannerType is not None:
15232 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
15233 
      oprot.writeI32(self.bannerType)
15234 
      oprot.writeFieldEnd()
8579 kshitij.so 15235 
    oprot.writeFieldStop()
15236 
    oprot.writeStructEnd()
15237 
 
15238 
  def validate(self):
15239 
    return
15240 
 
15241 
 
15242 
  def __repr__(self):
15243 
    L = ['%s=%r' % (key, value)
15244 
      for key, value in self.__dict__.iteritems()]
15245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15246 
 
15247 
  def __eq__(self, other):
15248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15249 
 
15250 
  def __ne__(self, other):
15251 
    return not (self == other)
15252 
 
15253 
class getUriMapping_result:
15254 
  """
15255 
  Attributes:
15256 
   - success
15257 
  """
15258 
 
15259 
  thrift_spec = (
15260 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
15261 
  )
15262 
 
15263 
  def __init__(self, success=None,):
15264 
    self.success = success
15265 
 
15266 
  def read(self, iprot):
15267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15269 
      return
15270 
    iprot.readStructBegin()
15271 
    while True:
15272 
      (fname, ftype, fid) = iprot.readFieldBegin()
15273 
      if ftype == TType.STOP:
15274 
        break
15275 
      if fid == 0:
15276 
        if ftype == TType.LIST:
15277 
          self.success = []
8590 kshitij.so 15278 
          (_etype242, _size239) = iprot.readListBegin()
15279 
          for _i243 in xrange(_size239):
15280 
            _elem244 = BannerUriMapping()
15281 
            _elem244.read(iprot)
15282 
            self.success.append(_elem244)
8579 kshitij.so 15283 
          iprot.readListEnd()
15284 
        else:
15285 
          iprot.skip(ftype)
15286 
      else:
15287 
        iprot.skip(ftype)
15288 
      iprot.readFieldEnd()
15289 
    iprot.readStructEnd()
15290 
 
15291 
  def write(self, oprot):
15292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15294 
      return
15295 
    oprot.writeStructBegin('getUriMapping_result')
15296 
    if self.success is not None:
15297 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15298 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15299 
      for iter245 in self.success:
15300 
        iter245.write(oprot)
8579 kshitij.so 15301 
      oprot.writeListEnd()
15302 
      oprot.writeFieldEnd()
15303 
    oprot.writeFieldStop()
15304 
    oprot.writeStructEnd()
15305 
 
15306 
  def validate(self):
15307 
    return
15308 
 
15309 
 
15310 
  def __repr__(self):
15311 
    L = ['%s=%r' % (key, value)
15312 
      for key, value in self.__dict__.iteritems()]
15313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15314 
 
15315 
  def __eq__(self, other):
15316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15317 
 
15318 
  def __ne__(self, other):
15319 
    return not (self == other)
15320 
 
15321 
class addCampaign_args:
15322 
  """
15323 
  Attributes:
15324 
   - campaign
15325 
  """
15326 
 
15327 
  thrift_spec = (
15328 
    None, # 0
15329 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
15330 
  )
15331 
 
15332 
  def __init__(self, campaign=None,):
15333 
    self.campaign = campaign
15334 
 
15335 
  def read(self, iprot):
15336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15338 
      return
15339 
    iprot.readStructBegin()
15340 
    while True:
15341 
      (fname, ftype, fid) = iprot.readFieldBegin()
15342 
      if ftype == TType.STOP:
15343 
        break
15344 
      if fid == 1:
15345 
        if ftype == TType.STRUCT:
15346 
          self.campaign = Campaign()
15347 
          self.campaign.read(iprot)
15348 
        else:
15349 
          iprot.skip(ftype)
15350 
      else:
15351 
        iprot.skip(ftype)
15352 
      iprot.readFieldEnd()
15353 
    iprot.readStructEnd()
15354 
 
15355 
  def write(self, oprot):
15356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15358 
      return
15359 
    oprot.writeStructBegin('addCampaign_args')
15360 
    if self.campaign is not None:
15361 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
15362 
      self.campaign.write(oprot)
15363 
      oprot.writeFieldEnd()
15364 
    oprot.writeFieldStop()
15365 
    oprot.writeStructEnd()
15366 
 
15367 
  def validate(self):
15368 
    return
15369 
 
15370 
 
15371 
  def __repr__(self):
15372 
    L = ['%s=%r' % (key, value)
15373 
      for key, value in self.__dict__.iteritems()]
15374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15375 
 
15376 
  def __eq__(self, other):
15377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15378 
 
15379 
  def __ne__(self, other):
15380 
    return not (self == other)
15381 
 
15382 
class addCampaign_result:
15383 
 
15384 
  thrift_spec = (
15385 
  )
15386 
 
15387 
  def read(self, iprot):
15388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15390 
      return
15391 
    iprot.readStructBegin()
15392 
    while True:
15393 
      (fname, ftype, fid) = iprot.readFieldBegin()
15394 
      if ftype == TType.STOP:
15395 
        break
15396 
      else:
15397 
        iprot.skip(ftype)
15398 
      iprot.readFieldEnd()
15399 
    iprot.readStructEnd()
15400 
 
15401 
  def write(self, oprot):
15402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15404 
      return
15405 
    oprot.writeStructBegin('addCampaign_result')
15406 
    oprot.writeFieldStop()
15407 
    oprot.writeStructEnd()
15408 
 
15409 
  def validate(self):
15410 
    return
15411 
 
15412 
 
15413 
  def __repr__(self):
15414 
    L = ['%s=%r' % (key, value)
15415 
      for key, value in self.__dict__.iteritems()]
15416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15417 
 
15418 
  def __eq__(self, other):
15419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15420 
 
15421 
  def __ne__(self, other):
15422 
    return not (self == other)
15423 
 
15424 
class getCampaigns_args:
15425 
  """
15426 
  Attributes:
15427 
   - campaignName
15428 
  """
15429 
 
15430 
  thrift_spec = (
15431 
    None, # 0
15432 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
15433 
  )
15434 
 
15435 
  def __init__(self, campaignName=None,):
15436 
    self.campaignName = campaignName
15437 
 
15438 
  def read(self, iprot):
15439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15441 
      return
15442 
    iprot.readStructBegin()
15443 
    while True:
15444 
      (fname, ftype, fid) = iprot.readFieldBegin()
15445 
      if ftype == TType.STOP:
15446 
        break
15447 
      if fid == 1:
15448 
        if ftype == TType.STRING:
15449 
          self.campaignName = iprot.readString();
15450 
        else:
15451 
          iprot.skip(ftype)
15452 
      else:
15453 
        iprot.skip(ftype)
15454 
      iprot.readFieldEnd()
15455 
    iprot.readStructEnd()
15456 
 
15457 
  def write(self, oprot):
15458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15460 
      return
15461 
    oprot.writeStructBegin('getCampaigns_args')
15462 
    if self.campaignName is not None:
15463 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
15464 
      oprot.writeString(self.campaignName)
15465 
      oprot.writeFieldEnd()
15466 
    oprot.writeFieldStop()
15467 
    oprot.writeStructEnd()
15468 
 
15469 
  def validate(self):
15470 
    return
15471 
 
15472 
 
15473 
  def __repr__(self):
15474 
    L = ['%s=%r' % (key, value)
15475 
      for key, value in self.__dict__.iteritems()]
15476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15477 
 
15478 
  def __eq__(self, other):
15479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15480 
 
15481 
  def __ne__(self, other):
15482 
    return not (self == other)
15483 
 
15484 
class getCampaigns_result:
15485 
  """
15486 
  Attributes:
15487 
   - success
15488 
  """
15489 
 
15490 
  thrift_spec = (
15491 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
15492 
  )
15493 
 
15494 
  def __init__(self, success=None,):
15495 
    self.success = success
15496 
 
15497 
  def read(self, iprot):
15498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15500 
      return
15501 
    iprot.readStructBegin()
15502 
    while True:
15503 
      (fname, ftype, fid) = iprot.readFieldBegin()
15504 
      if ftype == TType.STOP:
15505 
        break
15506 
      if fid == 0:
15507 
        if ftype == TType.LIST:
15508 
          self.success = []
8590 kshitij.so 15509 
          (_etype249, _size246) = iprot.readListBegin()
15510 
          for _i250 in xrange(_size246):
15511 
            _elem251 = Campaign()
15512 
            _elem251.read(iprot)
15513 
            self.success.append(_elem251)
8579 kshitij.so 15514 
          iprot.readListEnd()
15515 
        else:
15516 
          iprot.skip(ftype)
15517 
      else:
15518 
        iprot.skip(ftype)
15519 
      iprot.readFieldEnd()
15520 
    iprot.readStructEnd()
15521 
 
15522 
  def write(self, oprot):
15523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15525 
      return
15526 
    oprot.writeStructBegin('getCampaigns_result')
15527 
    if self.success is not None:
15528 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15529 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15530 
      for iter252 in self.success:
15531 
        iter252.write(oprot)
8579 kshitij.so 15532 
      oprot.writeListEnd()
15533 
      oprot.writeFieldEnd()
15534 
    oprot.writeFieldStop()
15535 
    oprot.writeStructEnd()
15536 
 
15537 
  def validate(self):
15538 
    return
15539 
 
15540 
 
15541 
  def __repr__(self):
15542 
    L = ['%s=%r' % (key, value)
15543 
      for key, value in self.__dict__.iteritems()]
15544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15545 
 
15546 
  def __eq__(self, other):
15547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15548 
 
15549 
  def __ne__(self, other):
15550 
    return not (self == other)
15551 
 
15552 
class deleteCampaign_args:
15553 
  """
15554 
  Attributes:
15555 
   - campaignId
15556 
  """
15557 
 
15558 
  thrift_spec = (
15559 
    None, # 0
15560 
    (1, TType.I64, 'campaignId', None, None, ), # 1
15561 
  )
15562 
 
15563 
  def __init__(self, campaignId=None,):
15564 
    self.campaignId = campaignId
15565 
 
15566 
  def read(self, iprot):
15567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15569 
      return
15570 
    iprot.readStructBegin()
15571 
    while True:
15572 
      (fname, ftype, fid) = iprot.readFieldBegin()
15573 
      if ftype == TType.STOP:
15574 
        break
15575 
      if fid == 1:
15576 
        if ftype == TType.I64:
15577 
          self.campaignId = iprot.readI64();
15578 
        else:
15579 
          iprot.skip(ftype)
15580 
      else:
15581 
        iprot.skip(ftype)
15582 
      iprot.readFieldEnd()
15583 
    iprot.readStructEnd()
15584 
 
15585 
  def write(self, oprot):
15586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15588 
      return
15589 
    oprot.writeStructBegin('deleteCampaign_args')
15590 
    if self.campaignId is not None:
15591 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
15592 
      oprot.writeI64(self.campaignId)
15593 
      oprot.writeFieldEnd()
15594 
    oprot.writeFieldStop()
15595 
    oprot.writeStructEnd()
15596 
 
15597 
  def validate(self):
15598 
    return
15599 
 
15600 
 
15601 
  def __repr__(self):
15602 
    L = ['%s=%r' % (key, value)
15603 
      for key, value in self.__dict__.iteritems()]
15604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15605 
 
15606 
  def __eq__(self, other):
15607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15608 
 
15609 
  def __ne__(self, other):
15610 
    return not (self == other)
15611 
 
15612 
class deleteCampaign_result:
15613 
 
15614 
  thrift_spec = (
15615 
  )
15616 
 
15617 
  def read(self, iprot):
15618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15620 
      return
15621 
    iprot.readStructBegin()
15622 
    while True:
15623 
      (fname, ftype, fid) = iprot.readFieldBegin()
15624 
      if ftype == TType.STOP:
15625 
        break
15626 
      else:
15627 
        iprot.skip(ftype)
15628 
      iprot.readFieldEnd()
15629 
    iprot.readStructEnd()
15630 
 
15631 
  def write(self, oprot):
15632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15634 
      return
15635 
    oprot.writeStructBegin('deleteCampaign_result')
15636 
    oprot.writeFieldStop()
15637 
    oprot.writeStructEnd()
15638 
 
15639 
  def validate(self):
15640 
    return
15641 
 
15642 
 
15643 
  def __repr__(self):
15644 
    L = ['%s=%r' % (key, value)
15645 
      for key, value in self.__dict__.iteritems()]
15646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15647 
 
15648 
  def __eq__(self, other):
15649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15650 
 
15651 
  def __ne__(self, other):
15652 
    return not (self == other)
15653 
 
15654 
class getAllCampaigns_args:
15655 
 
15656 
  thrift_spec = (
15657 
  )
15658 
 
15659 
  def read(self, iprot):
15660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15662 
      return
15663 
    iprot.readStructBegin()
15664 
    while True:
15665 
      (fname, ftype, fid) = iprot.readFieldBegin()
15666 
      if ftype == TType.STOP:
15667 
        break
15668 
      else:
15669 
        iprot.skip(ftype)
15670 
      iprot.readFieldEnd()
15671 
    iprot.readStructEnd()
15672 
 
15673 
  def write(self, oprot):
15674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15676 
      return
15677 
    oprot.writeStructBegin('getAllCampaigns_args')
15678 
    oprot.writeFieldStop()
15679 
    oprot.writeStructEnd()
15680 
 
15681 
  def validate(self):
15682 
    return
15683 
 
15684 
 
15685 
  def __repr__(self):
15686 
    L = ['%s=%r' % (key, value)
15687 
      for key, value in self.__dict__.iteritems()]
15688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15689 
 
15690 
  def __eq__(self, other):
15691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15692 
 
15693 
  def __ne__(self, other):
15694 
    return not (self == other)
15695 
 
15696 
class getAllCampaigns_result:
15697 
  """
15698 
  Attributes:
15699 
   - success
15700 
  """
15701 
 
15702 
  thrift_spec = (
15703 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15704 
  )
15705 
 
15706 
  def __init__(self, success=None,):
15707 
    self.success = success
15708 
 
15709 
  def read(self, iprot):
15710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15712 
      return
15713 
    iprot.readStructBegin()
15714 
    while True:
15715 
      (fname, ftype, fid) = iprot.readFieldBegin()
15716 
      if ftype == TType.STOP:
15717 
        break
15718 
      if fid == 0:
15719 
        if ftype == TType.LIST:
15720 
          self.success = []
8590 kshitij.so 15721 
          (_etype256, _size253) = iprot.readListBegin()
15722 
          for _i257 in xrange(_size253):
15723 
            _elem258 = iprot.readString();
15724 
            self.success.append(_elem258)
8579 kshitij.so 15725 
          iprot.readListEnd()
15726 
        else:
15727 
          iprot.skip(ftype)
15728 
      else:
15729 
        iprot.skip(ftype)
15730 
      iprot.readFieldEnd()
15731 
    iprot.readStructEnd()
15732 
 
15733 
  def write(self, oprot):
15734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15736 
      return
15737 
    oprot.writeStructBegin('getAllCampaigns_result')
15738 
    if self.success is not None:
15739 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15740 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 15741 
      for iter259 in self.success:
15742 
        oprot.writeString(iter259)
8579 kshitij.so 15743 
      oprot.writeListEnd()
15744 
      oprot.writeFieldEnd()
15745 
    oprot.writeFieldStop()
15746 
    oprot.writeStructEnd()
15747 
 
15748 
  def validate(self):
15749 
    return
15750 
 
15751 
 
15752 
  def __repr__(self):
15753 
    L = ['%s=%r' % (key, value)
15754 
      for key, value in self.__dict__.iteritems()]
15755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15756 
 
15757 
  def __eq__(self, other):
15758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15759 
 
15760 
  def __ne__(self, other):
15761 
    return not (self == other)
15762 
 
9155 kshitij.so 15763 
class getActiveBannersForMobileSite_args:
15764 
 
15765 
  thrift_spec = (
15766 
  )
15767 
 
15768 
  def read(self, iprot):
15769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15771 
      return
15772 
    iprot.readStructBegin()
15773 
    while True:
15774 
      (fname, ftype, fid) = iprot.readFieldBegin()
15775 
      if ftype == TType.STOP:
15776 
        break
15777 
      else:
15778 
        iprot.skip(ftype)
15779 
      iprot.readFieldEnd()
15780 
    iprot.readStructEnd()
15781 
 
15782 
  def write(self, oprot):
15783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15785 
      return
15786 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
15787 
    oprot.writeFieldStop()
15788 
    oprot.writeStructEnd()
15789 
 
15790 
  def validate(self):
15791 
    return
15792 
 
15793 
 
15794 
  def __repr__(self):
15795 
    L = ['%s=%r' % (key, value)
15796 
      for key, value in self.__dict__.iteritems()]
15797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15798 
 
15799 
  def __eq__(self, other):
15800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15801 
 
15802 
  def __ne__(self, other):
15803 
    return not (self == other)
15804 
 
15805 
class getActiveBannersForMobileSite_result:
15806 
  """
15807 
  Attributes:
15808 
   - success
15809 
  """
15810 
 
15811 
  thrift_spec = (
15812 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
15813 
  )
15814 
 
15815 
  def __init__(self, success=None,):
15816 
    self.success = success
15817 
 
15818 
  def read(self, iprot):
15819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15821 
      return
15822 
    iprot.readStructBegin()
15823 
    while True:
15824 
      (fname, ftype, fid) = iprot.readFieldBegin()
15825 
      if ftype == TType.STOP:
15826 
        break
15827 
      if fid == 0:
15828 
        if ftype == TType.MAP:
15829 
          self.success = {}
15830 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
15831 
          for _i264 in xrange(_size260):
15832 
            _key265 = iprot.readString();
15833 
            _val266 = []
15834 
            (_etype270, _size267) = iprot.readListBegin()
15835 
            for _i271 in xrange(_size267):
15836 
              _elem272 = Banner()
15837 
              _elem272.read(iprot)
15838 
              _val266.append(_elem272)
15839 
            iprot.readListEnd()
15840 
            self.success[_key265] = _val266
15841 
          iprot.readMapEnd()
15842 
        else:
15843 
          iprot.skip(ftype)
15844 
      else:
15845 
        iprot.skip(ftype)
15846 
      iprot.readFieldEnd()
15847 
    iprot.readStructEnd()
15848 
 
15849 
  def write(self, oprot):
15850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15852 
      return
15853 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
15854 
    if self.success is not None:
15855 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15856 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
15857 
      for kiter273,viter274 in self.success.items():
15858 
        oprot.writeString(kiter273)
15859 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
15860 
        for iter275 in viter274:
15861 
          iter275.write(oprot)
15862 
        oprot.writeListEnd()
15863 
      oprot.writeMapEnd()
15864 
      oprot.writeFieldEnd()
15865 
    oprot.writeFieldStop()
15866 
    oprot.writeStructEnd()
15867 
 
15868 
  def validate(self):
15869 
    return
15870 
 
15871 
 
15872 
  def __repr__(self):
15873 
    L = ['%s=%r' % (key, value)
15874 
      for key, value in self.__dict__.iteritems()]
15875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15876 
 
15877 
  def __eq__(self, other):
15878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15879 
 
15880 
  def __ne__(self, other):
15881 
    return not (self == other)
15882 
 
5944 mandeep.dh 15883 
class deleteSimilarItem_args:
15884 
  """
15885 
  Attributes:
15886 
   - itemId
15887 
   - catalogItemId
15888 
  """
15889 
 
15890 
  thrift_spec = (
15891 
    None, # 0
15892 
    (1, TType.I64, 'itemId', None, None, ), # 1
15893 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
15894 
  )
15895 
 
15896 
  def __init__(self, itemId=None, catalogItemId=None,):
15897 
    self.itemId = itemId
15898 
    self.catalogItemId = catalogItemId
15899 
 
15900 
  def read(self, iprot):
15901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15903 
      return
15904 
    iprot.readStructBegin()
15905 
    while True:
15906 
      (fname, ftype, fid) = iprot.readFieldBegin()
15907 
      if ftype == TType.STOP:
15908 
        break
15909 
      if fid == 1:
15910 
        if ftype == TType.I64:
15911 
          self.itemId = iprot.readI64();
15912 
        else:
15913 
          iprot.skip(ftype)
15914 
      elif fid == 2:
15915 
        if ftype == TType.I64:
15916 
          self.catalogItemId = iprot.readI64();
15917 
        else:
15918 
          iprot.skip(ftype)
15919 
      else:
15920 
        iprot.skip(ftype)
15921 
      iprot.readFieldEnd()
15922 
    iprot.readStructEnd()
15923 
 
15924 
  def write(self, oprot):
15925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15927 
      return
15928 
    oprot.writeStructBegin('deleteSimilarItem_args')
15929 
    if self.itemId is not None:
15930 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15931 
      oprot.writeI64(self.itemId)
15932 
      oprot.writeFieldEnd()
15933 
    if self.catalogItemId is not None:
15934 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
15935 
      oprot.writeI64(self.catalogItemId)
15936 
      oprot.writeFieldEnd()
15937 
    oprot.writeFieldStop()
15938 
    oprot.writeStructEnd()
15939 
 
15940 
  def validate(self):
15941 
    return
15942 
 
15943 
 
15944 
  def __repr__(self):
15945 
    L = ['%s=%r' % (key, value)
15946 
      for key, value in self.__dict__.iteritems()]
15947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15948 
 
15949 
  def __eq__(self, other):
15950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15951 
 
15952 
  def __ne__(self, other):
15953 
    return not (self == other)
15954 
 
15955 
class deleteSimilarItem_result:
15956 
  """
15957 
  Attributes:
15958 
   - success
15959 
   - cex
15960 
  """
15961 
 
15962 
  thrift_spec = (
15963 
    (0, TType.BOOL, 'success', None, None, ), # 0
15964 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15965 
  )
15966 
 
15967 
  def __init__(self, success=None, cex=None,):
15968 
    self.success = success
15969 
    self.cex = cex
15970 
 
15971 
  def read(self, iprot):
15972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15974 
      return
15975 
    iprot.readStructBegin()
15976 
    while True:
15977 
      (fname, ftype, fid) = iprot.readFieldBegin()
15978 
      if ftype == TType.STOP:
15979 
        break
15980 
      if fid == 0:
15981 
        if ftype == TType.BOOL:
15982 
          self.success = iprot.readBool();
15983 
        else:
15984 
          iprot.skip(ftype)
15985 
      elif fid == 1:
15986 
        if ftype == TType.STRUCT:
15987 
          self.cex = CatalogServiceException()
15988 
          self.cex.read(iprot)
15989 
        else:
15990 
          iprot.skip(ftype)
15991 
      else:
15992 
        iprot.skip(ftype)
15993 
      iprot.readFieldEnd()
15994 
    iprot.readStructEnd()
15995 
 
15996 
  def write(self, oprot):
15997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15999 
      return
16000 
    oprot.writeStructBegin('deleteSimilarItem_result')
16001 
    if self.success is not None:
16002 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16003 
      oprot.writeBool(self.success)
16004 
      oprot.writeFieldEnd()
16005 
    if self.cex is not None:
16006 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16007 
      self.cex.write(oprot)
16008 
      oprot.writeFieldEnd()
16009 
    oprot.writeFieldStop()
16010 
    oprot.writeStructEnd()
16011 
 
16012 
  def validate(self):
16013 
    return
16014 
 
16015 
 
16016 
  def __repr__(self):
16017 
    L = ['%s=%r' % (key, value)
16018 
      for key, value in self.__dict__.iteritems()]
16019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16020 
 
16021 
  def __eq__(self, other):
16022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16023 
 
16024 
  def __ne__(self, other):
16025 
    return not (self == other)
16026 
 
16027 
class checkSimilarItem_args:
16028 
  """
16029 
  Attributes:
16030 
   - brand
16031 
   - modelNumber
16032 
   - modelName
16033 
   - color
16034 
  """
16035 
 
16036 
  thrift_spec = (
16037 
    None, # 0
16038 
    (1, TType.STRING, 'brand', None, None, ), # 1
16039 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
16040 
    (3, TType.STRING, 'modelName', None, None, ), # 3
16041 
    (4, TType.STRING, 'color', None, None, ), # 4
16042 
  )
16043 
 
16044 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
16045 
    self.brand = brand
16046 
    self.modelNumber = modelNumber
16047 
    self.modelName = modelName
16048 
    self.color = color
16049 
 
16050 
  def read(self, iprot):
16051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16053 
      return
16054 
    iprot.readStructBegin()
16055 
    while True:
16056 
      (fname, ftype, fid) = iprot.readFieldBegin()
16057 
      if ftype == TType.STOP:
16058 
        break
16059 
      if fid == 1:
16060 
        if ftype == TType.STRING:
16061 
          self.brand = iprot.readString();
16062 
        else:
16063 
          iprot.skip(ftype)
16064 
      elif fid == 2:
16065 
        if ftype == TType.STRING:
16066 
          self.modelNumber = iprot.readString();
16067 
        else:
16068 
          iprot.skip(ftype)
16069 
      elif fid == 3:
16070 
        if ftype == TType.STRING:
16071 
          self.modelName = iprot.readString();
16072 
        else:
16073 
          iprot.skip(ftype)
16074 
      elif fid == 4:
16075 
        if ftype == TType.STRING:
16076 
          self.color = iprot.readString();
16077 
        else:
16078 
          iprot.skip(ftype)
16079 
      else:
16080 
        iprot.skip(ftype)
16081 
      iprot.readFieldEnd()
16082 
    iprot.readStructEnd()
16083 
 
16084 
  def write(self, oprot):
16085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16087 
      return
16088 
    oprot.writeStructBegin('checkSimilarItem_args')
16089 
    if self.brand is not None:
16090 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
16091 
      oprot.writeString(self.brand)
16092 
      oprot.writeFieldEnd()
16093 
    if self.modelNumber is not None:
16094 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
16095 
      oprot.writeString(self.modelNumber)
16096 
      oprot.writeFieldEnd()
16097 
    if self.modelName is not None:
16098 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
16099 
      oprot.writeString(self.modelName)
16100 
      oprot.writeFieldEnd()
16101 
    if self.color is not None:
16102 
      oprot.writeFieldBegin('color', TType.STRING, 4)
16103 
      oprot.writeString(self.color)
16104 
      oprot.writeFieldEnd()
16105 
    oprot.writeFieldStop()
16106 
    oprot.writeStructEnd()
16107 
 
16108 
  def validate(self):
16109 
    return
16110 
 
16111 
 
16112 
  def __repr__(self):
16113 
    L = ['%s=%r' % (key, value)
16114 
      for key, value in self.__dict__.iteritems()]
16115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16116 
 
16117 
  def __eq__(self, other):
16118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16119 
 
16120 
  def __ne__(self, other):
16121 
    return not (self == other)
16122 
 
16123 
class checkSimilarItem_result:
16124 
  """
16125 
  Attributes:
16126 
   - success
16127 
  """
16128 
 
16129 
  thrift_spec = (
16130 
    (0, TType.I64, 'success', None, None, ), # 0
16131 
  )
16132 
 
16133 
  def __init__(self, success=None,):
16134 
    self.success = success
16135 
 
16136 
  def read(self, iprot):
16137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16139 
      return
16140 
    iprot.readStructBegin()
16141 
    while True:
16142 
      (fname, ftype, fid) = iprot.readFieldBegin()
16143 
      if ftype == TType.STOP:
16144 
        break
16145 
      if fid == 0:
16146 
        if ftype == TType.I64:
16147 
          self.success = iprot.readI64();
16148 
        else:
16149 
          iprot.skip(ftype)
16150 
      else:
16151 
        iprot.skip(ftype)
16152 
      iprot.readFieldEnd()
16153 
    iprot.readStructEnd()
16154 
 
16155 
  def write(self, oprot):
16156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16158 
      return
16159 
    oprot.writeStructBegin('checkSimilarItem_result')
16160 
    if self.success is not None:
16161 
      oprot.writeFieldBegin('success', TType.I64, 0)
16162 
      oprot.writeI64(self.success)
16163 
      oprot.writeFieldEnd()
16164 
    oprot.writeFieldStop()
16165 
    oprot.writeStructEnd()
16166 
 
16167 
  def validate(self):
16168 
    return
16169 
 
16170 
 
16171 
  def __repr__(self):
16172 
    L = ['%s=%r' % (key, value)
16173 
      for key, value in self.__dict__.iteritems()]
16174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16175 
 
16176 
  def __eq__(self, other):
16177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16178 
 
16179 
  def __ne__(self, other):
16180 
    return not (self == other)
16181 
 
16182 
class validateRiskyStatus_args:
16183 
  """
16184 
  Attributes:
16185 
   - itemId
16186 
  """
16187 
 
16188 
  thrift_spec = (
16189 
    None, # 0
16190 
    (1, TType.I64, 'itemId', None, None, ), # 1
16191 
  )
16192 
 
16193 
  def __init__(self, itemId=None,):
16194 
    self.itemId = itemId
16195 
 
16196 
  def read(self, iprot):
16197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16199 
      return
16200 
    iprot.readStructBegin()
16201 
    while True:
16202 
      (fname, ftype, fid) = iprot.readFieldBegin()
16203 
      if ftype == TType.STOP:
16204 
        break
16205 
      if fid == 1:
16206 
        if ftype == TType.I64:
16207 
          self.itemId = iprot.readI64();
16208 
        else:
16209 
          iprot.skip(ftype)
16210 
      else:
16211 
        iprot.skip(ftype)
16212 
      iprot.readFieldEnd()
16213 
    iprot.readStructEnd()
16214 
 
16215 
  def write(self, oprot):
16216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16218 
      return
16219 
    oprot.writeStructBegin('validateRiskyStatus_args')
16220 
    if self.itemId is not None:
16221 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16222 
      oprot.writeI64(self.itemId)
16223 
      oprot.writeFieldEnd()
16224 
    oprot.writeFieldStop()
16225 
    oprot.writeStructEnd()
16226 
 
16227 
  def validate(self):
16228 
    return
16229 
 
16230 
 
16231 
  def __repr__(self):
16232 
    L = ['%s=%r' % (key, value)
16233 
      for key, value in self.__dict__.iteritems()]
16234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16235 
 
16236 
  def __eq__(self, other):
16237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16238 
 
16239 
  def __ne__(self, other):
16240 
    return not (self == other)
16241 
 
16242 
class validateRiskyStatus_result:
16243 
 
16244 
  thrift_spec = (
16245 
  )
16246 
 
16247 
  def read(self, iprot):
16248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16250 
      return
16251 
    iprot.readStructBegin()
16252 
    while True:
16253 
      (fname, ftype, fid) = iprot.readFieldBegin()
16254 
      if ftype == TType.STOP:
16255 
        break
16256 
      else:
16257 
        iprot.skip(ftype)
16258 
      iprot.readFieldEnd()
16259 
    iprot.readStructEnd()
16260 
 
16261 
  def write(self, oprot):
16262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16264 
      return
16265 
    oprot.writeStructBegin('validateRiskyStatus_result')
16266 
    oprot.writeFieldStop()
16267 
    oprot.writeStructEnd()
16268 
 
16269 
  def validate(self):
16270 
    return
16271 
 
16272 
 
16273 
  def __repr__(self):
16274 
    L = ['%s=%r' % (key, value)
16275 
      for key, value in self.__dict__.iteritems()]
16276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16277 
 
16278 
  def __eq__(self, other):
16279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16280 
 
16281 
  def __ne__(self, other):
16282 
    return not (self == other)
16283 
 
16284 
class changeItemRiskyFlag_args:
16285 
  """
16286 
  Attributes:
16287 
   - itemId
16288 
   - risky
16289 
  """
16290 
 
16291 
  thrift_spec = (
16292 
    None, # 0
16293 
    (1, TType.I64, 'itemId', None, None, ), # 1
16294 
    (2, TType.BOOL, 'risky', None, None, ), # 2
16295 
  )
16296 
 
16297 
  def __init__(self, itemId=None, risky=None,):
16298 
    self.itemId = itemId
16299 
    self.risky = risky
16300 
 
16301 
  def read(self, iprot):
16302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16304 
      return
16305 
    iprot.readStructBegin()
16306 
    while True:
16307 
      (fname, ftype, fid) = iprot.readFieldBegin()
16308 
      if ftype == TType.STOP:
16309 
        break
16310 
      if fid == 1:
16311 
        if ftype == TType.I64:
16312 
          self.itemId = iprot.readI64();
16313 
        else:
16314 
          iprot.skip(ftype)
16315 
      elif fid == 2:
16316 
        if ftype == TType.BOOL:
16317 
          self.risky = iprot.readBool();
16318 
        else:
16319 
          iprot.skip(ftype)
16320 
      else:
16321 
        iprot.skip(ftype)
16322 
      iprot.readFieldEnd()
16323 
    iprot.readStructEnd()
16324 
 
16325 
  def write(self, oprot):
16326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16328 
      return
16329 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
16330 
    if self.itemId is not None:
16331 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16332 
      oprot.writeI64(self.itemId)
16333 
      oprot.writeFieldEnd()
16334 
    if self.risky is not None:
16335 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
16336 
      oprot.writeBool(self.risky)
16337 
      oprot.writeFieldEnd()
16338 
    oprot.writeFieldStop()
16339 
    oprot.writeStructEnd()
16340 
 
16341 
  def validate(self):
16342 
    return
16343 
 
16344 
 
16345 
  def __repr__(self):
16346 
    L = ['%s=%r' % (key, value)
16347 
      for key, value in self.__dict__.iteritems()]
16348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16349 
 
16350 
  def __eq__(self, other):
16351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16352 
 
16353 
  def __ne__(self, other):
16354 
    return not (self == other)
16355 
 
16356 
class changeItemRiskyFlag_result:
16357 
 
16358 
  thrift_spec = (
16359 
  )
16360 
 
16361 
  def read(self, iprot):
16362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16364 
      return
16365 
    iprot.readStructBegin()
16366 
    while True:
16367 
      (fname, ftype, fid) = iprot.readFieldBegin()
16368 
      if ftype == TType.STOP:
16369 
        break
16370 
      else:
16371 
        iprot.skip(ftype)
16372 
      iprot.readFieldEnd()
16373 
    iprot.readStructEnd()
16374 
 
16375 
  def write(self, oprot):
16376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16378 
      return
16379 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
16380 
    oprot.writeFieldStop()
16381 
    oprot.writeStructEnd()
16382 
 
16383 
  def validate(self):
16384 
    return
16385 
 
16386 
 
16387 
  def __repr__(self):
16388 
    L = ['%s=%r' % (key, value)
16389 
      for key, value in self.__dict__.iteritems()]
16390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16391 
 
16392 
  def __eq__(self, other):
16393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16394 
 
16395 
  def __ne__(self, other):
16396 
    return not (self == other)
16397 
 
16398 
class getItemsByRiskyFlag_args:
16399 
 
16400 
  thrift_spec = (
16401 
  )
16402 
 
16403 
  def read(self, iprot):
16404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16406 
      return
16407 
    iprot.readStructBegin()
16408 
    while True:
16409 
      (fname, ftype, fid) = iprot.readFieldBegin()
16410 
      if ftype == TType.STOP:
16411 
        break
16412 
      else:
16413 
        iprot.skip(ftype)
16414 
      iprot.readFieldEnd()
16415 
    iprot.readStructEnd()
16416 
 
16417 
  def write(self, oprot):
16418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16420 
      return
16421 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
16422 
    oprot.writeFieldStop()
16423 
    oprot.writeStructEnd()
16424 
 
16425 
  def validate(self):
16426 
    return
16427 
 
16428 
 
16429 
  def __repr__(self):
16430 
    L = ['%s=%r' % (key, value)
16431 
      for key, value in self.__dict__.iteritems()]
16432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16433 
 
16434 
  def __eq__(self, other):
16435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16436 
 
16437 
  def __ne__(self, other):
16438 
    return not (self == other)
16439 
 
16440 
class getItemsByRiskyFlag_result:
16441 
  """
16442 
  Attributes:
16443 
   - success
16444 
  """
16445 
 
16446 
  thrift_spec = (
16447 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16448 
  )
16449 
 
16450 
  def __init__(self, success=None,):
16451 
    self.success = success
16452 
 
16453 
  def read(self, iprot):
16454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16456 
      return
16457 
    iprot.readStructBegin()
16458 
    while True:
16459 
      (fname, ftype, fid) = iprot.readFieldBegin()
16460 
      if ftype == TType.STOP:
16461 
        break
16462 
      if fid == 0:
16463 
        if ftype == TType.LIST:
16464 
          self.success = []
9155 kshitij.so 16465 
          (_etype279, _size276) = iprot.readListBegin()
16466 
          for _i280 in xrange(_size276):
16467 
            _elem281 = Item()
16468 
            _elem281.read(iprot)
16469 
            self.success.append(_elem281)
5944 mandeep.dh 16470 
          iprot.readListEnd()
16471 
        else:
16472 
          iprot.skip(ftype)
16473 
      else:
16474 
        iprot.skip(ftype)
16475 
      iprot.readFieldEnd()
16476 
    iprot.readStructEnd()
16477 
 
16478 
  def write(self, oprot):
16479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16481 
      return
16482 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
16483 
    if self.success is not None:
16484 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16485 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16486 
      for iter282 in self.success:
16487 
        iter282.write(oprot)
5944 mandeep.dh 16488 
      oprot.writeListEnd()
16489 
      oprot.writeFieldEnd()
16490 
    oprot.writeFieldStop()
16491 
    oprot.writeStructEnd()
16492 
 
16493 
  def validate(self):
16494 
    return
16495 
 
16496 
 
16497 
  def __repr__(self):
16498 
    L = ['%s=%r' % (key, value)
16499 
      for key, value in self.__dict__.iteritems()]
16500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16501 
 
16502 
  def __eq__(self, other):
16503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16504 
 
16505 
  def __ne__(self, other):
16506 
    return not (self == other)
16507 
 
16508 
class getItemsForMasterSheet_args:
16509 
  """
16510 
  Attributes:
16511 
   - category
16512 
   - brand
16513 
  """
16514 
 
16515 
  thrift_spec = (
16516 
    None, # 0
16517 
    (1, TType.STRING, 'category', None, None, ), # 1
16518 
    (2, TType.STRING, 'brand', None, None, ), # 2
16519 
  )
16520 
 
16521 
  def __init__(self, category=None, brand=None,):
16522 
    self.category = category
16523 
    self.brand = brand
16524 
 
16525 
  def read(self, iprot):
16526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16528 
      return
16529 
    iprot.readStructBegin()
16530 
    while True:
16531 
      (fname, ftype, fid) = iprot.readFieldBegin()
16532 
      if ftype == TType.STOP:
16533 
        break
16534 
      if fid == 1:
16535 
        if ftype == TType.STRING:
16536 
          self.category = iprot.readString();
16537 
        else:
16538 
          iprot.skip(ftype)
16539 
      elif fid == 2:
16540 
        if ftype == TType.STRING:
16541 
          self.brand = iprot.readString();
16542 
        else:
16543 
          iprot.skip(ftype)
16544 
      else:
16545 
        iprot.skip(ftype)
16546 
      iprot.readFieldEnd()
16547 
    iprot.readStructEnd()
16548 
 
16549 
  def write(self, oprot):
16550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16552 
      return
16553 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
16554 
    if self.category is not None:
16555 
      oprot.writeFieldBegin('category', TType.STRING, 1)
16556 
      oprot.writeString(self.category)
16557 
      oprot.writeFieldEnd()
16558 
    if self.brand is not None:
16559 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
16560 
      oprot.writeString(self.brand)
16561 
      oprot.writeFieldEnd()
16562 
    oprot.writeFieldStop()
16563 
    oprot.writeStructEnd()
16564 
 
16565 
  def validate(self):
16566 
    return
16567 
 
16568 
 
16569 
  def __repr__(self):
16570 
    L = ['%s=%r' % (key, value)
16571 
      for key, value in self.__dict__.iteritems()]
16572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16573 
 
16574 
  def __eq__(self, other):
16575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16576 
 
16577 
  def __ne__(self, other):
16578 
    return not (self == other)
16579 
 
16580 
class getItemsForMasterSheet_result:
16581 
  """
16582 
  Attributes:
16583 
   - success
16584 
  """
16585 
 
16586 
  thrift_spec = (
16587 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16588 
  )
16589 
 
16590 
  def __init__(self, success=None,):
16591 
    self.success = success
16592 
 
16593 
  def read(self, iprot):
16594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16596 
      return
16597 
    iprot.readStructBegin()
16598 
    while True:
16599 
      (fname, ftype, fid) = iprot.readFieldBegin()
16600 
      if ftype == TType.STOP:
16601 
        break
16602 
      if fid == 0:
16603 
        if ftype == TType.LIST:
16604 
          self.success = []
9155 kshitij.so 16605 
          (_etype286, _size283) = iprot.readListBegin()
16606 
          for _i287 in xrange(_size283):
16607 
            _elem288 = Item()
16608 
            _elem288.read(iprot)
16609 
            self.success.append(_elem288)
5944 mandeep.dh 16610 
          iprot.readListEnd()
16611 
        else:
16612 
          iprot.skip(ftype)
16613 
      else:
16614 
        iprot.skip(ftype)
16615 
      iprot.readFieldEnd()
16616 
    iprot.readStructEnd()
16617 
 
16618 
  def write(self, oprot):
16619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16621 
      return
16622 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
16623 
    if self.success is not None:
16624 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16625 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16626 
      for iter289 in self.success:
16627 
        iter289.write(oprot)
5944 mandeep.dh 16628 
      oprot.writeListEnd()
16629 
      oprot.writeFieldEnd()
16630 
    oprot.writeFieldStop()
16631 
    oprot.writeStructEnd()
16632 
 
16633 
  def validate(self):
16634 
    return
16635 
 
16636 
 
16637 
  def __repr__(self):
16638 
    L = ['%s=%r' % (key, value)
16639 
      for key, value in self.__dict__.iteritems()]
16640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16641 
 
16642 
  def __eq__(self, other):
16643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16644 
 
16645 
  def __ne__(self, other):
16646 
    return not (self == other)
16647 
 
16648 
class getSimilarItemsCatalogIds_args:
16649 
  """
16650 
  Attributes:
16651 
   - beginIndex
16652 
   - totalItems
16653 
   - itemId
16654 
  """
16655 
 
16656 
  thrift_spec = (
16657 
    None, # 0
16658 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
16659 
    (2, TType.I64, 'totalItems', None, None, ), # 2
16660 
    (3, TType.I64, 'itemId', None, None, ), # 3
16661 
  )
16662 
 
16663 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
16664 
    self.beginIndex = beginIndex
16665 
    self.totalItems = totalItems
16666 
    self.itemId = itemId
16667 
 
16668 
  def read(self, iprot):
16669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16671 
      return
16672 
    iprot.readStructBegin()
16673 
    while True:
16674 
      (fname, ftype, fid) = iprot.readFieldBegin()
16675 
      if ftype == TType.STOP:
16676 
        break
16677 
      if fid == 1:
16678 
        if ftype == TType.I64:
16679 
          self.beginIndex = iprot.readI64();
16680 
        else:
16681 
          iprot.skip(ftype)
16682 
      elif fid == 2:
16683 
        if ftype == TType.I64:
16684 
          self.totalItems = iprot.readI64();
16685 
        else:
16686 
          iprot.skip(ftype)
16687 
      elif fid == 3:
16688 
        if ftype == TType.I64:
16689 
          self.itemId = iprot.readI64();
16690 
        else:
16691 
          iprot.skip(ftype)
16692 
      else:
16693 
        iprot.skip(ftype)
16694 
      iprot.readFieldEnd()
16695 
    iprot.readStructEnd()
16696 
 
16697 
  def write(self, oprot):
16698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16700 
      return
16701 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
16702 
    if self.beginIndex is not None:
16703 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
16704 
      oprot.writeI64(self.beginIndex)
16705 
      oprot.writeFieldEnd()
16706 
    if self.totalItems is not None:
16707 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
16708 
      oprot.writeI64(self.totalItems)
16709 
      oprot.writeFieldEnd()
16710 
    if self.itemId is not None:
16711 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
16712 
      oprot.writeI64(self.itemId)
16713 
      oprot.writeFieldEnd()
16714 
    oprot.writeFieldStop()
16715 
    oprot.writeStructEnd()
16716 
 
16717 
  def validate(self):
16718 
    return
16719 
 
16720 
 
16721 
  def __repr__(self):
16722 
    L = ['%s=%r' % (key, value)
16723 
      for key, value in self.__dict__.iteritems()]
16724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16725 
 
16726 
  def __eq__(self, other):
16727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16728 
 
16729 
  def __ne__(self, other):
16730 
    return not (self == other)
16731 
 
16732 
class getSimilarItemsCatalogIds_result:
16733 
  """
16734 
  Attributes:
16735 
   - success
16736 
  """
16737 
 
16738 
  thrift_spec = (
16739 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
16740 
  )
16741 
 
16742 
  def __init__(self, success=None,):
16743 
    self.success = success
16744 
 
16745 
  def read(self, iprot):
16746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16748 
      return
16749 
    iprot.readStructBegin()
16750 
    while True:
16751 
      (fname, ftype, fid) = iprot.readFieldBegin()
16752 
      if ftype == TType.STOP:
16753 
        break
16754 
      if fid == 0:
16755 
        if ftype == TType.LIST:
16756 
          self.success = []
9155 kshitij.so 16757 
          (_etype293, _size290) = iprot.readListBegin()
16758 
          for _i294 in xrange(_size290):
16759 
            _elem295 = iprot.readI64();
16760 
            self.success.append(_elem295)
5944 mandeep.dh 16761 
          iprot.readListEnd()
16762 
        else:
16763 
          iprot.skip(ftype)
16764 
      else:
16765 
        iprot.skip(ftype)
16766 
      iprot.readFieldEnd()
16767 
    iprot.readStructEnd()
16768 
 
16769 
  def write(self, oprot):
16770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16772 
      return
16773 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
16774 
    if self.success is not None:
16775 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16776 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 16777 
      for iter296 in self.success:
16778 
        oprot.writeI64(iter296)
5944 mandeep.dh 16779 
      oprot.writeListEnd()
16780 
      oprot.writeFieldEnd()
16781 
    oprot.writeFieldStop()
16782 
    oprot.writeStructEnd()
16783 
 
16784 
  def validate(self):
16785 
    return
16786 
 
16787 
 
16788 
  def __repr__(self):
16789 
    L = ['%s=%r' % (key, value)
16790 
      for key, value in self.__dict__.iteritems()]
16791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16792 
 
16793 
  def __eq__(self, other):
16794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16795 
 
16796 
  def __ne__(self, other):
16797 
    return not (self == other)
16798 
 
16799 
class addProductNotification_args:
16800 
  """
16801 
  Attributes:
16802 
   - itemId
16803 
   - email
16804 
  """
16805 
 
16806 
  thrift_spec = None
16807 
  def __init__(self, itemId=None, email=None,):
16808 
    self.itemId = itemId
16809 
    self.email = email
16810 
 
16811 
  def read(self, iprot):
16812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16814 
      return
16815 
    iprot.readStructBegin()
16816 
    while True:
16817 
      (fname, ftype, fid) = iprot.readFieldBegin()
16818 
      if ftype == TType.STOP:
16819 
        break
16820 
      if fid == -1:
16821 
        if ftype == TType.I64:
16822 
          self.itemId = iprot.readI64();
16823 
        else:
16824 
          iprot.skip(ftype)
16825 
      elif fid == -2:
16826 
        if ftype == TType.STRING:
16827 
          self.email = iprot.readString();
16828 
        else:
16829 
          iprot.skip(ftype)
16830 
      else:
16831 
        iprot.skip(ftype)
16832 
      iprot.readFieldEnd()
16833 
    iprot.readStructEnd()
16834 
 
16835 
  def write(self, oprot):
16836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16838 
      return
16839 
    oprot.writeStructBegin('addProductNotification_args')
16840 
    if self.email is not None:
16841 
      oprot.writeFieldBegin('email', TType.STRING, -2)
16842 
      oprot.writeString(self.email)
16843 
      oprot.writeFieldEnd()
16844 
    if self.itemId is not None:
16845 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
16846 
      oprot.writeI64(self.itemId)
16847 
      oprot.writeFieldEnd()
16848 
    oprot.writeFieldStop()
16849 
    oprot.writeStructEnd()
16850 
 
16851 
  def validate(self):
16852 
    return
16853 
 
16854 
 
16855 
  def __repr__(self):
16856 
    L = ['%s=%r' % (key, value)
16857 
      for key, value in self.__dict__.iteritems()]
16858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16859 
 
16860 
  def __eq__(self, other):
16861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16862 
 
16863 
  def __ne__(self, other):
16864 
    return not (self == other)
16865 
 
16866 
class addProductNotification_result:
16867 
  """
16868 
  Attributes:
16869 
   - success
16870 
  """
16871 
 
16872 
  thrift_spec = (
16873 
    (0, TType.BOOL, 'success', None, None, ), # 0
16874 
  )
16875 
 
16876 
  def __init__(self, success=None,):
16877 
    self.success = success
16878 
 
16879 
  def read(self, iprot):
16880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16882 
      return
16883 
    iprot.readStructBegin()
16884 
    while True:
16885 
      (fname, ftype, fid) = iprot.readFieldBegin()
16886 
      if ftype == TType.STOP:
16887 
        break
16888 
      if fid == 0:
16889 
        if ftype == TType.BOOL:
16890 
          self.success = iprot.readBool();
16891 
        else:
16892 
          iprot.skip(ftype)
16893 
      else:
16894 
        iprot.skip(ftype)
16895 
      iprot.readFieldEnd()
16896 
    iprot.readStructEnd()
16897 
 
16898 
  def write(self, oprot):
16899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16901 
      return
16902 
    oprot.writeStructBegin('addProductNotification_result')
16903 
    if self.success is not None:
16904 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16905 
      oprot.writeBool(self.success)
16906 
      oprot.writeFieldEnd()
16907 
    oprot.writeFieldStop()
16908 
    oprot.writeStructEnd()
16909 
 
16910 
  def validate(self):
16911 
    return
16912 
 
16913 
 
16914 
  def __repr__(self):
16915 
    L = ['%s=%r' % (key, value)
16916 
      for key, value in self.__dict__.iteritems()]
16917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16918 
 
16919 
  def __eq__(self, other):
16920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16921 
 
16922 
  def __ne__(self, other):
16923 
    return not (self == other)
16924 
 
16925 
class sendProductNotifications_args:
16926 
 
16927 
  thrift_spec = (
16928 
  )
16929 
 
16930 
  def read(self, iprot):
16931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16933 
      return
16934 
    iprot.readStructBegin()
16935 
    while True:
16936 
      (fname, ftype, fid) = iprot.readFieldBegin()
16937 
      if ftype == TType.STOP:
16938 
        break
16939 
      else:
16940 
        iprot.skip(ftype)
16941 
      iprot.readFieldEnd()
16942 
    iprot.readStructEnd()
16943 
 
16944 
  def write(self, oprot):
16945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16947 
      return
16948 
    oprot.writeStructBegin('sendProductNotifications_args')
16949 
    oprot.writeFieldStop()
16950 
    oprot.writeStructEnd()
16951 
 
16952 
  def validate(self):
16953 
    return
16954 
 
16955 
 
16956 
  def __repr__(self):
16957 
    L = ['%s=%r' % (key, value)
16958 
      for key, value in self.__dict__.iteritems()]
16959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16960 
 
16961 
  def __eq__(self, other):
16962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16963 
 
16964 
  def __ne__(self, other):
16965 
    return not (self == other)
16966 
 
16967 
class sendProductNotifications_result:
16968 
  """
16969 
  Attributes:
16970 
   - success
16971 
  """
16972 
 
16973 
  thrift_spec = (
16974 
    (0, TType.BOOL, 'success', None, None, ), # 0
16975 
  )
16976 
 
16977 
  def __init__(self, success=None,):
16978 
    self.success = success
16979 
 
16980 
  def read(self, iprot):
16981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16983 
      return
16984 
    iprot.readStructBegin()
16985 
    while True:
16986 
      (fname, ftype, fid) = iprot.readFieldBegin()
16987 
      if ftype == TType.STOP:
16988 
        break
16989 
      if fid == 0:
16990 
        if ftype == TType.BOOL:
16991 
          self.success = iprot.readBool();
16992 
        else:
16993 
          iprot.skip(ftype)
16994 
      else:
16995 
        iprot.skip(ftype)
16996 
      iprot.readFieldEnd()
16997 
    iprot.readStructEnd()
16998 
 
16999 
  def write(self, oprot):
17000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17002 
      return
17003 
    oprot.writeStructBegin('sendProductNotifications_result')
17004 
    if self.success is not None:
17005 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17006 
      oprot.writeBool(self.success)
17007 
      oprot.writeFieldEnd()
17008 
    oprot.writeFieldStop()
17009 
    oprot.writeStructEnd()
17010 
 
17011 
  def validate(self):
17012 
    return
17013 
 
17014 
 
17015 
  def __repr__(self):
17016 
    L = ['%s=%r' % (key, value)
17017 
      for key, value in self.__dict__.iteritems()]
17018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17019 
 
17020 
  def __eq__(self, other):
17021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17022 
 
17023 
  def __ne__(self, other):
17024 
    return not (self == other)
17025 
 
17026 
class getAllBrandsByCategory_args:
17027 
  """
17028 
  Attributes:
17029 
   - categoryId
17030 
  """
17031 
 
17032 
  thrift_spec = (
17033 
    None, # 0
17034 
    (1, TType.I64, 'categoryId', None, None, ), # 1
17035 
  )
17036 
 
17037 
  def __init__(self, categoryId=None,):
17038 
    self.categoryId = categoryId
17039 
 
17040 
  def read(self, iprot):
17041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17043 
      return
17044 
    iprot.readStructBegin()
17045 
    while True:
17046 
      (fname, ftype, fid) = iprot.readFieldBegin()
17047 
      if ftype == TType.STOP:
17048 
        break
17049 
      if fid == 1:
17050 
        if ftype == TType.I64:
17051 
          self.categoryId = iprot.readI64();
17052 
        else:
17053 
          iprot.skip(ftype)
17054 
      else:
17055 
        iprot.skip(ftype)
17056 
      iprot.readFieldEnd()
17057 
    iprot.readStructEnd()
17058 
 
17059 
  def write(self, oprot):
17060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17062 
      return
17063 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
17064 
    if self.categoryId is not None:
17065 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
17066 
      oprot.writeI64(self.categoryId)
17067 
      oprot.writeFieldEnd()
17068 
    oprot.writeFieldStop()
17069 
    oprot.writeStructEnd()
17070 
 
17071 
  def validate(self):
17072 
    return
17073 
 
17074 
 
17075 
  def __repr__(self):
17076 
    L = ['%s=%r' % (key, value)
17077 
      for key, value in self.__dict__.iteritems()]
17078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17079 
 
17080 
  def __eq__(self, other):
17081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17082 
 
17083 
  def __ne__(self, other):
17084 
    return not (self == other)
17085 
 
17086 
class getAllBrandsByCategory_result:
17087 
  """
17088 
  Attributes:
17089 
   - success
17090 
  """
17091 
 
17092 
  thrift_spec = (
17093 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
17094 
  )
17095 
 
17096 
  def __init__(self, success=None,):
17097 
    self.success = success
17098 
 
17099 
  def read(self, iprot):
17100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17102 
      return
17103 
    iprot.readStructBegin()
17104 
    while True:
17105 
      (fname, ftype, fid) = iprot.readFieldBegin()
17106 
      if ftype == TType.STOP:
17107 
        break
17108 
      if fid == 0:
17109 
        if ftype == TType.LIST:
17110 
          self.success = []
9155 kshitij.so 17111 
          (_etype300, _size297) = iprot.readListBegin()
17112 
          for _i301 in xrange(_size297):
17113 
            _elem302 = iprot.readString();
17114 
            self.success.append(_elem302)
5944 mandeep.dh 17115 
          iprot.readListEnd()
17116 
        else:
17117 
          iprot.skip(ftype)
17118 
      else:
17119 
        iprot.skip(ftype)
17120 
      iprot.readFieldEnd()
17121 
    iprot.readStructEnd()
17122 
 
17123 
  def write(self, oprot):
17124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17126 
      return
17127 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
17128 
    if self.success is not None:
17129 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17130 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 17131 
      for iter303 in self.success:
17132 
        oprot.writeString(iter303)
5944 mandeep.dh 17133 
      oprot.writeListEnd()
17134 
      oprot.writeFieldEnd()
17135 
    oprot.writeFieldStop()
17136 
    oprot.writeStructEnd()
17137 
 
17138 
  def validate(self):
17139 
    return
17140 
 
17141 
 
17142 
  def __repr__(self):
17143 
    L = ['%s=%r' % (key, value)
17144 
      for key, value in self.__dict__.iteritems()]
17145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17146 
 
17147 
  def __eq__(self, other):
17148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17149 
 
17150 
  def __ne__(self, other):
17151 
    return not (self == other)
17152 
 
17153 
class getAllBrands_args:
17154 
 
17155 
  thrift_spec = (
17156 
  )
17157 
 
17158 
  def read(self, iprot):
17159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17161 
      return
17162 
    iprot.readStructBegin()
17163 
    while True:
17164 
      (fname, ftype, fid) = iprot.readFieldBegin()
17165 
      if ftype == TType.STOP:
17166 
        break
17167 
      else:
17168 
        iprot.skip(ftype)
17169 
      iprot.readFieldEnd()
17170 
    iprot.readStructEnd()
17171 
 
17172 
  def write(self, oprot):
17173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17175 
      return
17176 
    oprot.writeStructBegin('getAllBrands_args')
17177 
    oprot.writeFieldStop()
17178 
    oprot.writeStructEnd()
17179 
 
17180 
  def validate(self):
17181 
    return
17182 
 
17183 
 
17184 
  def __repr__(self):
17185 
    L = ['%s=%r' % (key, value)
17186 
      for key, value in self.__dict__.iteritems()]
17187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17188 
 
17189 
  def __eq__(self, other):
17190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17191 
 
17192 
  def __ne__(self, other):
17193 
    return not (self == other)
17194 
 
17195 
class getAllBrands_result:
17196 
  """
17197 
  Attributes:
17198 
   - success
17199 
  """
17200 
 
17201 
  thrift_spec = (
17202 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
17203 
  )
17204 
 
17205 
  def __init__(self, success=None,):
17206 
    self.success = success
17207 
 
17208 
  def read(self, iprot):
17209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17211 
      return
17212 
    iprot.readStructBegin()
17213 
    while True:
17214 
      (fname, ftype, fid) = iprot.readFieldBegin()
17215 
      if ftype == TType.STOP:
17216 
        break
17217 
      if fid == 0:
17218 
        if ftype == TType.LIST:
17219 
          self.success = []
9155 kshitij.so 17220 
          (_etype307, _size304) = iprot.readListBegin()
17221 
          for _i308 in xrange(_size304):
17222 
            _elem309 = iprot.readString();
17223 
            self.success.append(_elem309)
5944 mandeep.dh 17224 
          iprot.readListEnd()
17225 
        else:
17226 
          iprot.skip(ftype)
17227 
      else:
17228 
        iprot.skip(ftype)
17229 
      iprot.readFieldEnd()
17230 
    iprot.readStructEnd()
17231 
 
17232 
  def write(self, oprot):
17233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17235 
      return
17236 
    oprot.writeStructBegin('getAllBrands_result')
17237 
    if self.success is not None:
17238 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17239 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 17240 
      for iter310 in self.success:
17241 
        oprot.writeString(iter310)
5944 mandeep.dh 17242 
      oprot.writeListEnd()
17243 
      oprot.writeFieldEnd()
17244 
    oprot.writeFieldStop()
17245 
    oprot.writeStructEnd()
17246 
 
17247 
  def validate(self):
17248 
    return
17249 
 
17250 
 
17251 
  def __repr__(self):
17252 
    L = ['%s=%r' % (key, value)
17253 
      for key, value in self.__dict__.iteritems()]
17254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17255 
 
17256 
  def __eq__(self, other):
17257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17258 
 
17259 
  def __ne__(self, other):
17260 
    return not (self == other)
17261 
 
17262 
class getAllSources_args:
17263 
 
17264 
  thrift_spec = (
17265 
  )
17266 
 
17267 
  def read(self, iprot):
17268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17270 
      return
17271 
    iprot.readStructBegin()
17272 
    while True:
17273 
      (fname, ftype, fid) = iprot.readFieldBegin()
17274 
      if ftype == TType.STOP:
17275 
        break
17276 
      else:
17277 
        iprot.skip(ftype)
17278 
      iprot.readFieldEnd()
17279 
    iprot.readStructEnd()
17280 
 
17281 
  def write(self, oprot):
17282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17284 
      return
17285 
    oprot.writeStructBegin('getAllSources_args')
17286 
    oprot.writeFieldStop()
17287 
    oprot.writeStructEnd()
17288 
 
17289 
  def validate(self):
17290 
    return
17291 
 
17292 
 
17293 
  def __repr__(self):
17294 
    L = ['%s=%r' % (key, value)
17295 
      for key, value in self.__dict__.iteritems()]
17296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17297 
 
17298 
  def __eq__(self, other):
17299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17300 
 
17301 
  def __ne__(self, other):
17302 
    return not (self == other)
17303 
 
17304 
class getAllSources_result:
17305 
  """
17306 
  Attributes:
17307 
   - success
17308 
  """
17309 
 
17310 
  thrift_spec = (
17311 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
17312 
  )
17313 
 
17314 
  def __init__(self, success=None,):
17315 
    self.success = success
17316 
 
17317 
  def read(self, iprot):
17318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17320 
      return
17321 
    iprot.readStructBegin()
17322 
    while True:
17323 
      (fname, ftype, fid) = iprot.readFieldBegin()
17324 
      if ftype == TType.STOP:
17325 
        break
17326 
      if fid == 0:
17327 
        if ftype == TType.LIST:
17328 
          self.success = []
9155 kshitij.so 17329 
          (_etype314, _size311) = iprot.readListBegin()
17330 
          for _i315 in xrange(_size311):
17331 
            _elem316 = Source()
17332 
            _elem316.read(iprot)
17333 
            self.success.append(_elem316)
5944 mandeep.dh 17334 
          iprot.readListEnd()
17335 
        else:
17336 
          iprot.skip(ftype)
17337 
      else:
17338 
        iprot.skip(ftype)
17339 
      iprot.readFieldEnd()
17340 
    iprot.readStructEnd()
17341 
 
17342 
  def write(self, oprot):
17343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17345 
      return
17346 
    oprot.writeStructBegin('getAllSources_result')
17347 
    if self.success is not None:
17348 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17349 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17350 
      for iter317 in self.success:
17351 
        iter317.write(oprot)
5944 mandeep.dh 17352 
      oprot.writeListEnd()
17353 
      oprot.writeFieldEnd()
17354 
    oprot.writeFieldStop()
17355 
    oprot.writeStructEnd()
17356 
 
17357 
  def validate(self):
17358 
    return
17359 
 
17360 
 
17361 
  def __repr__(self):
17362 
    L = ['%s=%r' % (key, value)
17363 
      for key, value in self.__dict__.iteritems()]
17364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17365 
 
17366 
  def __eq__(self, other):
17367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17368 
 
17369 
  def __ne__(self, other):
17370 
    return not (self == other)
17371 
 
17372 
class getItemPricingBySource_args:
17373 
  """
17374 
  Attributes:
17375 
   - itemId
17376 
   - sourceId
17377 
  """
17378 
 
17379 
  thrift_spec = (
17380 
    None, # 0
17381 
    (1, TType.I64, 'itemId', None, None, ), # 1
17382 
    (2, TType.I64, 'sourceId', None, None, ), # 2
17383 
  )
17384 
 
17385 
  def __init__(self, itemId=None, sourceId=None,):
17386 
    self.itemId = itemId
17387 
    self.sourceId = sourceId
17388 
 
17389 
  def read(self, iprot):
17390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17392 
      return
17393 
    iprot.readStructBegin()
17394 
    while True:
17395 
      (fname, ftype, fid) = iprot.readFieldBegin()
17396 
      if ftype == TType.STOP:
17397 
        break
17398 
      if fid == 1:
17399 
        if ftype == TType.I64:
17400 
          self.itemId = iprot.readI64();
17401 
        else:
17402 
          iprot.skip(ftype)
17403 
      elif fid == 2:
17404 
        if ftype == TType.I64:
17405 
          self.sourceId = iprot.readI64();
17406 
        else:
17407 
          iprot.skip(ftype)
17408 
      else:
17409 
        iprot.skip(ftype)
17410 
      iprot.readFieldEnd()
17411 
    iprot.readStructEnd()
17412 
 
17413 
  def write(self, oprot):
17414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17416 
      return
17417 
    oprot.writeStructBegin('getItemPricingBySource_args')
17418 
    if self.itemId is not None:
17419 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17420 
      oprot.writeI64(self.itemId)
17421 
      oprot.writeFieldEnd()
17422 
    if self.sourceId is not None:
17423 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
17424 
      oprot.writeI64(self.sourceId)
17425 
      oprot.writeFieldEnd()
17426 
    oprot.writeFieldStop()
17427 
    oprot.writeStructEnd()
17428 
 
17429 
  def validate(self):
17430 
    return
17431 
 
17432 
 
17433 
  def __repr__(self):
17434 
    L = ['%s=%r' % (key, value)
17435 
      for key, value in self.__dict__.iteritems()]
17436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17437 
 
17438 
  def __eq__(self, other):
17439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17440 
 
17441 
  def __ne__(self, other):
17442 
    return not (self == other)
17443 
 
17444 
class getItemPricingBySource_result:
17445 
  """
17446 
  Attributes:
17447 
   - success
17448 
   - cex
17449 
  """
17450 
 
17451 
  thrift_spec = (
17452 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
17453 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17454 
  )
17455 
 
17456 
  def __init__(self, success=None, cex=None,):
17457 
    self.success = success
17458 
    self.cex = cex
17459 
 
17460 
  def read(self, iprot):
17461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17463 
      return
17464 
    iprot.readStructBegin()
17465 
    while True:
17466 
      (fname, ftype, fid) = iprot.readFieldBegin()
17467 
      if ftype == TType.STOP:
17468 
        break
17469 
      if fid == 0:
17470 
        if ftype == TType.STRUCT:
17471 
          self.success = SourceItemPricing()
17472 
          self.success.read(iprot)
17473 
        else:
17474 
          iprot.skip(ftype)
17475 
      elif fid == 1:
17476 
        if ftype == TType.STRUCT:
17477 
          self.cex = CatalogServiceException()
17478 
          self.cex.read(iprot)
17479 
        else:
17480 
          iprot.skip(ftype)
17481 
      else:
17482 
        iprot.skip(ftype)
17483 
      iprot.readFieldEnd()
17484 
    iprot.readStructEnd()
17485 
 
17486 
  def write(self, oprot):
17487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17489 
      return
17490 
    oprot.writeStructBegin('getItemPricingBySource_result')
17491 
    if self.success is not None:
17492 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17493 
      self.success.write(oprot)
17494 
      oprot.writeFieldEnd()
17495 
    if self.cex is not None:
17496 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17497 
      self.cex.write(oprot)
17498 
      oprot.writeFieldEnd()
17499 
    oprot.writeFieldStop()
17500 
    oprot.writeStructEnd()
17501 
 
17502 
  def validate(self):
17503 
    return
17504 
 
17505 
 
17506 
  def __repr__(self):
17507 
    L = ['%s=%r' % (key, value)
17508 
      for key, value in self.__dict__.iteritems()]
17509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17510 
 
17511 
  def __eq__(self, other):
17512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17513 
 
17514 
  def __ne__(self, other):
17515 
    return not (self == other)
17516 
 
17517 
class addSourceItemPricing_args:
17518 
  """
17519 
  Attributes:
17520 
   - sourceItemPricing
17521 
  """
17522 
 
17523 
  thrift_spec = (
17524 
    None, # 0
17525 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
17526 
  )
17527 
 
17528 
  def __init__(self, sourceItemPricing=None,):
17529 
    self.sourceItemPricing = sourceItemPricing
17530 
 
17531 
  def read(self, iprot):
17532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17534 
      return
17535 
    iprot.readStructBegin()
17536 
    while True:
17537 
      (fname, ftype, fid) = iprot.readFieldBegin()
17538 
      if ftype == TType.STOP:
17539 
        break
17540 
      if fid == 1:
17541 
        if ftype == TType.STRUCT:
17542 
          self.sourceItemPricing = SourceItemPricing()
17543 
          self.sourceItemPricing.read(iprot)
17544 
        else:
17545 
          iprot.skip(ftype)
17546 
      else:
17547 
        iprot.skip(ftype)
17548 
      iprot.readFieldEnd()
17549 
    iprot.readStructEnd()
17550 
 
17551 
  def write(self, oprot):
17552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17554 
      return
17555 
    oprot.writeStructBegin('addSourceItemPricing_args')
17556 
    if self.sourceItemPricing is not None:
17557 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
17558 
      self.sourceItemPricing.write(oprot)
17559 
      oprot.writeFieldEnd()
17560 
    oprot.writeFieldStop()
17561 
    oprot.writeStructEnd()
17562 
 
17563 
  def validate(self):
17564 
    return
17565 
 
17566 
 
17567 
  def __repr__(self):
17568 
    L = ['%s=%r' % (key, value)
17569 
      for key, value in self.__dict__.iteritems()]
17570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17571 
 
17572 
  def __eq__(self, other):
17573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17574 
 
17575 
  def __ne__(self, other):
17576 
    return not (self == other)
17577 
 
17578 
class addSourceItemPricing_result:
17579 
  """
17580 
  Attributes:
17581 
   - cex
17582 
  """
17583 
 
17584 
  thrift_spec = (
17585 
    None, # 0
17586 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17587 
  )
17588 
 
17589 
  def __init__(self, cex=None,):
17590 
    self.cex = cex
17591 
 
17592 
  def read(self, iprot):
17593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17595 
      return
17596 
    iprot.readStructBegin()
17597 
    while True:
17598 
      (fname, ftype, fid) = iprot.readFieldBegin()
17599 
      if ftype == TType.STOP:
17600 
        break
17601 
      if fid == 1:
17602 
        if ftype == TType.STRUCT:
17603 
          self.cex = CatalogServiceException()
17604 
          self.cex.read(iprot)
17605 
        else:
17606 
          iprot.skip(ftype)
17607 
      else:
17608 
        iprot.skip(ftype)
17609 
      iprot.readFieldEnd()
17610 
    iprot.readStructEnd()
17611 
 
17612 
  def write(self, oprot):
17613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17615 
      return
17616 
    oprot.writeStructBegin('addSourceItemPricing_result')
17617 
    if self.cex is not None:
17618 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17619 
      self.cex.write(oprot)
17620 
      oprot.writeFieldEnd()
17621 
    oprot.writeFieldStop()
17622 
    oprot.writeStructEnd()
17623 
 
17624 
  def validate(self):
17625 
    return
17626 
 
17627 
 
17628 
  def __repr__(self):
17629 
    L = ['%s=%r' % (key, value)
17630 
      for key, value in self.__dict__.iteritems()]
17631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17632 
 
17633 
  def __eq__(self, other):
17634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17635 
 
17636 
  def __ne__(self, other):
17637 
    return not (self == other)
17638 
 
17639 
class getAllSourcePricing_args:
17640 
  """
17641 
  Attributes:
17642 
   - itemId
17643 
  """
17644 
 
17645 
  thrift_spec = (
17646 
    None, # 0
17647 
    (1, TType.I64, 'itemId', None, None, ), # 1
17648 
  )
17649 
 
17650 
  def __init__(self, itemId=None,):
17651 
    self.itemId = itemId
17652 
 
17653 
  def read(self, iprot):
17654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17656 
      return
17657 
    iprot.readStructBegin()
17658 
    while True:
17659 
      (fname, ftype, fid) = iprot.readFieldBegin()
17660 
      if ftype == TType.STOP:
17661 
        break
17662 
      if fid == 1:
17663 
        if ftype == TType.I64:
17664 
          self.itemId = iprot.readI64();
17665 
        else:
17666 
          iprot.skip(ftype)
17667 
      else:
17668 
        iprot.skip(ftype)
17669 
      iprot.readFieldEnd()
17670 
    iprot.readStructEnd()
17671 
 
17672 
  def write(self, oprot):
17673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17675 
      return
17676 
    oprot.writeStructBegin('getAllSourcePricing_args')
17677 
    if self.itemId is not None:
17678 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17679 
      oprot.writeI64(self.itemId)
17680 
      oprot.writeFieldEnd()
17681 
    oprot.writeFieldStop()
17682 
    oprot.writeStructEnd()
17683 
 
17684 
  def validate(self):
17685 
    return
17686 
 
17687 
 
17688 
  def __repr__(self):
17689 
    L = ['%s=%r' % (key, value)
17690 
      for key, value in self.__dict__.iteritems()]
17691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17692 
 
17693 
  def __eq__(self, other):
17694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17695 
 
17696 
  def __ne__(self, other):
17697 
    return not (self == other)
17698 
 
17699 
class getAllSourcePricing_result:
17700 
  """
17701 
  Attributes:
17702 
   - success
17703 
   - cex
17704 
  """
17705 
 
17706 
  thrift_spec = (
17707 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
17708 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17709 
  )
17710 
 
17711 
  def __init__(self, success=None, cex=None,):
17712 
    self.success = success
17713 
    self.cex = cex
17714 
 
17715 
  def read(self, iprot):
17716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17718 
      return
17719 
    iprot.readStructBegin()
17720 
    while True:
17721 
      (fname, ftype, fid) = iprot.readFieldBegin()
17722 
      if ftype == TType.STOP:
17723 
        break
17724 
      if fid == 0:
17725 
        if ftype == TType.LIST:
17726 
          self.success = []
9155 kshitij.so 17727 
          (_etype321, _size318) = iprot.readListBegin()
17728 
          for _i322 in xrange(_size318):
17729 
            _elem323 = SourceItemPricing()
17730 
            _elem323.read(iprot)
17731 
            self.success.append(_elem323)
5944 mandeep.dh 17732 
          iprot.readListEnd()
17733 
        else:
17734 
          iprot.skip(ftype)
17735 
      elif fid == 1:
17736 
        if ftype == TType.STRUCT:
17737 
          self.cex = CatalogServiceException()
17738 
          self.cex.read(iprot)
17739 
        else:
17740 
          iprot.skip(ftype)
17741 
      else:
17742 
        iprot.skip(ftype)
17743 
      iprot.readFieldEnd()
17744 
    iprot.readStructEnd()
17745 
 
17746 
  def write(self, oprot):
17747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17749 
      return
17750 
    oprot.writeStructBegin('getAllSourcePricing_result')
17751 
    if self.success is not None:
17752 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17753 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17754 
      for iter324 in self.success:
17755 
        iter324.write(oprot)
5944 mandeep.dh 17756 
      oprot.writeListEnd()
17757 
      oprot.writeFieldEnd()
17758 
    if self.cex is not None:
17759 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17760 
      self.cex.write(oprot)
17761 
      oprot.writeFieldEnd()
17762 
    oprot.writeFieldStop()
17763 
    oprot.writeStructEnd()
17764 
 
17765 
  def validate(self):
17766 
    return
17767 
 
17768 
 
17769 
  def __repr__(self):
17770 
    L = ['%s=%r' % (key, value)
17771 
      for key, value in self.__dict__.iteritems()]
17772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17773 
 
17774 
  def __eq__(self, other):
17775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17776 
 
17777 
  def __ne__(self, other):
17778 
    return not (self == other)
17779 
 
17780 
class getItemForSource_args:
17781 
  """
17782 
  Attributes:
17783 
   - item_id
17784 
   - sourceId
17785 
  """
17786 
 
17787 
  thrift_spec = (
17788 
    None, # 0
17789 
    (1, TType.I64, 'item_id', None, None, ), # 1
17790 
    (2, TType.I64, 'sourceId', None, None, ), # 2
17791 
  )
17792 
 
17793 
  def __init__(self, item_id=None, sourceId=None,):
17794 
    self.item_id = item_id
17795 
    self.sourceId = sourceId
17796 
 
17797 
  def read(self, iprot):
17798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17800 
      return
17801 
    iprot.readStructBegin()
17802 
    while True:
17803 
      (fname, ftype, fid) = iprot.readFieldBegin()
17804 
      if ftype == TType.STOP:
17805 
        break
17806 
      if fid == 1:
17807 
        if ftype == TType.I64:
17808 
          self.item_id = iprot.readI64();
17809 
        else:
17810 
          iprot.skip(ftype)
17811 
      elif fid == 2:
17812 
        if ftype == TType.I64:
17813 
          self.sourceId = iprot.readI64();
17814 
        else:
17815 
          iprot.skip(ftype)
17816 
      else:
17817 
        iprot.skip(ftype)
17818 
      iprot.readFieldEnd()
17819 
    iprot.readStructEnd()
17820 
 
17821 
  def write(self, oprot):
17822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17824 
      return
17825 
    oprot.writeStructBegin('getItemForSource_args')
17826 
    if self.item_id is not None:
17827 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
17828 
      oprot.writeI64(self.item_id)
17829 
      oprot.writeFieldEnd()
17830 
    if self.sourceId is not None:
17831 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
17832 
      oprot.writeI64(self.sourceId)
17833 
      oprot.writeFieldEnd()
17834 
    oprot.writeFieldStop()
17835 
    oprot.writeStructEnd()
17836 
 
17837 
  def validate(self):
17838 
    return
17839 
 
17840 
 
17841 
  def __repr__(self):
17842 
    L = ['%s=%r' % (key, value)
17843 
      for key, value in self.__dict__.iteritems()]
17844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17845 
 
17846 
  def __eq__(self, other):
17847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17848 
 
17849 
  def __ne__(self, other):
17850 
    return not (self == other)
17851 
 
17852 
class getItemForSource_result:
17853 
  """
17854 
  Attributes:
17855 
   - success
17856 
   - cex
17857 
  """
17858 
 
17859 
  thrift_spec = (
17860 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
17861 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17862 
  )
17863 
 
17864 
  def __init__(self, success=None, cex=None,):
17865 
    self.success = success
17866 
    self.cex = cex
17867 
 
17868 
  def read(self, iprot):
17869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17871 
      return
17872 
    iprot.readStructBegin()
17873 
    while True:
17874 
      (fname, ftype, fid) = iprot.readFieldBegin()
17875 
      if ftype == TType.STOP:
17876 
        break
17877 
      if fid == 0:
17878 
        if ftype == TType.STRUCT:
17879 
          self.success = Item()
17880 
          self.success.read(iprot)
17881 
        else:
17882 
          iprot.skip(ftype)
17883 
      elif fid == 1:
17884 
        if ftype == TType.STRUCT:
17885 
          self.cex = CatalogServiceException()
17886 
          self.cex.read(iprot)
17887 
        else:
17888 
          iprot.skip(ftype)
17889 
      else:
17890 
        iprot.skip(ftype)
17891 
      iprot.readFieldEnd()
17892 
    iprot.readStructEnd()
17893 
 
17894 
  def write(self, oprot):
17895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17897 
      return
17898 
    oprot.writeStructBegin('getItemForSource_result')
17899 
    if self.success is not None:
17900 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17901 
      self.success.write(oprot)
17902 
      oprot.writeFieldEnd()
17903 
    if self.cex is not None:
17904 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17905 
      self.cex.write(oprot)
17906 
      oprot.writeFieldEnd()
17907 
    oprot.writeFieldStop()
17908 
    oprot.writeStructEnd()
17909 
 
17910 
  def validate(self):
17911 
    return
17912 
 
17913 
 
17914 
  def __repr__(self):
17915 
    L = ['%s=%r' % (key, value)
17916 
      for key, value in self.__dict__.iteritems()]
17917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17918 
 
17919 
  def __eq__(self, other):
17920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17921 
 
17922 
  def __ne__(self, other):
17923 
    return not (self == other)
17924 
 
17925 
class searchItemsInRange_args:
17926 
  """
17927 
  Attributes:
17928 
   - searchTerms
17929 
   - offset
17930 
   - limit
17931 
  """
17932 
 
17933 
  thrift_spec = (
17934 
    None, # 0
17935 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17936 
    (2, TType.I64, 'offset', None, None, ), # 2
17937 
    (3, TType.I64, 'limit', None, None, ), # 3
17938 
  )
17939 
 
17940 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
17941 
    self.searchTerms = searchTerms
17942 
    self.offset = offset
17943 
    self.limit = limit
17944 
 
17945 
  def read(self, iprot):
17946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17948 
      return
17949 
    iprot.readStructBegin()
17950 
    while True:
17951 
      (fname, ftype, fid) = iprot.readFieldBegin()
17952 
      if ftype == TType.STOP:
17953 
        break
17954 
      if fid == 1:
17955 
        if ftype == TType.LIST:
17956 
          self.searchTerms = []
9155 kshitij.so 17957 
          (_etype328, _size325) = iprot.readListBegin()
17958 
          for _i329 in xrange(_size325):
17959 
            _elem330 = iprot.readString();
17960 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 17961 
          iprot.readListEnd()
17962 
        else:
17963 
          iprot.skip(ftype)
17964 
      elif fid == 2:
17965 
        if ftype == TType.I64:
17966 
          self.offset = iprot.readI64();
17967 
        else:
17968 
          iprot.skip(ftype)
17969 
      elif fid == 3:
17970 
        if ftype == TType.I64:
17971 
          self.limit = iprot.readI64();
17972 
        else:
17973 
          iprot.skip(ftype)
17974 
      else:
17975 
        iprot.skip(ftype)
17976 
      iprot.readFieldEnd()
17977 
    iprot.readStructEnd()
17978 
 
17979 
  def write(self, oprot):
17980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17982 
      return
17983 
    oprot.writeStructBegin('searchItemsInRange_args')
17984 
    if self.searchTerms is not None:
17985 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17986 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17987 
      for iter331 in self.searchTerms:
17988 
        oprot.writeString(iter331)
5944 mandeep.dh 17989 
      oprot.writeListEnd()
17990 
      oprot.writeFieldEnd()
17991 
    if self.offset is not None:
17992 
      oprot.writeFieldBegin('offset', TType.I64, 2)
17993 
      oprot.writeI64(self.offset)
17994 
      oprot.writeFieldEnd()
17995 
    if self.limit is not None:
17996 
      oprot.writeFieldBegin('limit', TType.I64, 3)
17997 
      oprot.writeI64(self.limit)
17998 
      oprot.writeFieldEnd()
17999 
    oprot.writeFieldStop()
18000 
    oprot.writeStructEnd()
18001 
 
18002 
  def validate(self):
18003 
    return
18004 
 
18005 
 
18006 
  def __repr__(self):
18007 
    L = ['%s=%r' % (key, value)
18008 
      for key, value in self.__dict__.iteritems()]
18009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18010 
 
18011 
  def __eq__(self, other):
18012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18013 
 
18014 
  def __ne__(self, other):
18015 
    return not (self == other)
18016 
 
18017 
class searchItemsInRange_result:
18018 
  """
18019 
  Attributes:
18020 
   - success
18021 
  """
18022 
 
18023 
  thrift_spec = (
18024 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18025 
  )
18026 
 
18027 
  def __init__(self, success=None,):
18028 
    self.success = success
18029 
 
18030 
  def read(self, iprot):
18031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18033 
      return
18034 
    iprot.readStructBegin()
18035 
    while True:
18036 
      (fname, ftype, fid) = iprot.readFieldBegin()
18037 
      if ftype == TType.STOP:
18038 
        break
18039 
      if fid == 0:
18040 
        if ftype == TType.LIST:
18041 
          self.success = []
9155 kshitij.so 18042 
          (_etype335, _size332) = iprot.readListBegin()
18043 
          for _i336 in xrange(_size332):
18044 
            _elem337 = Item()
18045 
            _elem337.read(iprot)
18046 
            self.success.append(_elem337)
5944 mandeep.dh 18047 
          iprot.readListEnd()
18048 
        else:
18049 
          iprot.skip(ftype)
18050 
      else:
18051 
        iprot.skip(ftype)
18052 
      iprot.readFieldEnd()
18053 
    iprot.readStructEnd()
18054 
 
18055 
  def write(self, oprot):
18056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18058 
      return
18059 
    oprot.writeStructBegin('searchItemsInRange_result')
18060 
    if self.success is not None:
18061 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18062 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18063 
      for iter338 in self.success:
18064 
        iter338.write(oprot)
5944 mandeep.dh 18065 
      oprot.writeListEnd()
18066 
      oprot.writeFieldEnd()
18067 
    oprot.writeFieldStop()
18068 
    oprot.writeStructEnd()
18069 
 
18070 
  def validate(self):
18071 
    return
18072 
 
18073 
 
18074 
  def __repr__(self):
18075 
    L = ['%s=%r' % (key, value)
18076 
      for key, value in self.__dict__.iteritems()]
18077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18078 
 
18079 
  def __eq__(self, other):
18080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18081 
 
18082 
  def __ne__(self, other):
18083 
    return not (self == other)
18084 
 
18085 
class getSearchResultCount_args:
18086 
  """
18087 
  Attributes:
18088 
   - searchTerms
18089 
  """
18090 
 
18091 
  thrift_spec = (
18092 
    None, # 0
18093 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
18094 
  )
18095 
 
18096 
  def __init__(self, searchTerms=None,):
18097 
    self.searchTerms = searchTerms
18098 
 
18099 
  def read(self, iprot):
18100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18102 
      return
18103 
    iprot.readStructBegin()
18104 
    while True:
18105 
      (fname, ftype, fid) = iprot.readFieldBegin()
18106 
      if ftype == TType.STOP:
18107 
        break
18108 
      if fid == 1:
18109 
        if ftype == TType.LIST:
18110 
          self.searchTerms = []
9155 kshitij.so 18111 
          (_etype342, _size339) = iprot.readListBegin()
18112 
          for _i343 in xrange(_size339):
18113 
            _elem344 = iprot.readString();
18114 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 18115 
          iprot.readListEnd()
18116 
        else:
18117 
          iprot.skip(ftype)
18118 
      else:
18119 
        iprot.skip(ftype)
18120 
      iprot.readFieldEnd()
18121 
    iprot.readStructEnd()
18122 
 
18123 
  def write(self, oprot):
18124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18126 
      return
18127 
    oprot.writeStructBegin('getSearchResultCount_args')
18128 
    if self.searchTerms is not None:
18129 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
18130 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 18131 
      for iter345 in self.searchTerms:
18132 
        oprot.writeString(iter345)
5944 mandeep.dh 18133 
      oprot.writeListEnd()
18134 
      oprot.writeFieldEnd()
18135 
    oprot.writeFieldStop()
18136 
    oprot.writeStructEnd()
18137 
 
18138 
  def validate(self):
18139 
    return
18140 
 
18141 
 
18142 
  def __repr__(self):
18143 
    L = ['%s=%r' % (key, value)
18144 
      for key, value in self.__dict__.iteritems()]
18145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18146 
 
18147 
  def __eq__(self, other):
18148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18149 
 
18150 
  def __ne__(self, other):
18151 
    return not (self == other)
18152 
 
18153 
class getSearchResultCount_result:
18154 
  """
18155 
  Attributes:
18156 
   - success
18157 
  """
18158 
 
18159 
  thrift_spec = (
18160 
    (0, TType.I32, 'success', None, None, ), # 0
18161 
  )
18162 
 
18163 
  def __init__(self, success=None,):
18164 
    self.success = success
18165 
 
18166 
  def read(self, iprot):
18167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18169 
      return
18170 
    iprot.readStructBegin()
18171 
    while True:
18172 
      (fname, ftype, fid) = iprot.readFieldBegin()
18173 
      if ftype == TType.STOP:
18174 
        break
18175 
      if fid == 0:
18176 
        if ftype == TType.I32:
18177 
          self.success = iprot.readI32();
18178 
        else:
18179 
          iprot.skip(ftype)
18180 
      else:
18181 
        iprot.skip(ftype)
18182 
      iprot.readFieldEnd()
18183 
    iprot.readStructEnd()
18184 
 
18185 
  def write(self, oprot):
18186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18188 
      return
18189 
    oprot.writeStructBegin('getSearchResultCount_result')
18190 
    if self.success is not None:
18191 
      oprot.writeFieldBegin('success', TType.I32, 0)
18192 
      oprot.writeI32(self.success)
18193 
      oprot.writeFieldEnd()
18194 
    oprot.writeFieldStop()
18195 
    oprot.writeStructEnd()
18196 
 
18197 
  def validate(self):
18198 
    return
18199 
 
18200 
 
18201 
  def __repr__(self):
18202 
    L = ['%s=%r' % (key, value)
18203 
      for key, value in self.__dict__.iteritems()]
18204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18205 
 
18206 
  def __eq__(self, other):
18207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18208 
 
18209 
  def __ne__(self, other):
18210 
    return not (self == other)
18211 
 
18212 
class getProductNotifications_args:
18213 
  """
18214 
  Attributes:
18215 
   - startDateTime
18216 
  """
18217 
 
18218 
  thrift_spec = (
18219 
    None, # 0
18220 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
18221 
  )
18222 
 
18223 
  def __init__(self, startDateTime=None,):
18224 
    self.startDateTime = startDateTime
18225 
 
18226 
  def read(self, iprot):
18227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18229 
      return
18230 
    iprot.readStructBegin()
18231 
    while True:
18232 
      (fname, ftype, fid) = iprot.readFieldBegin()
18233 
      if ftype == TType.STOP:
18234 
        break
18235 
      if fid == 1:
18236 
        if ftype == TType.I64:
18237 
          self.startDateTime = iprot.readI64();
18238 
        else:
18239 
          iprot.skip(ftype)
18240 
      else:
18241 
        iprot.skip(ftype)
18242 
      iprot.readFieldEnd()
18243 
    iprot.readStructEnd()
18244 
 
18245 
  def write(self, oprot):
18246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18248 
      return
18249 
    oprot.writeStructBegin('getProductNotifications_args')
18250 
    if self.startDateTime is not None:
18251 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
18252 
      oprot.writeI64(self.startDateTime)
18253 
      oprot.writeFieldEnd()
18254 
    oprot.writeFieldStop()
18255 
    oprot.writeStructEnd()
18256 
 
18257 
  def validate(self):
18258 
    return
18259 
 
18260 
 
18261 
  def __repr__(self):
18262 
    L = ['%s=%r' % (key, value)
18263 
      for key, value in self.__dict__.iteritems()]
18264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18265 
 
18266 
  def __eq__(self, other):
18267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18268 
 
18269 
  def __ne__(self, other):
18270 
    return not (self == other)
18271 
 
18272 
class getProductNotifications_result:
18273 
  """
18274 
  Attributes:
18275 
   - success
18276 
  """
18277 
 
18278 
  thrift_spec = (
18279 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
18280 
  )
18281 
 
18282 
  def __init__(self, success=None,):
18283 
    self.success = success
18284 
 
18285 
  def read(self, iprot):
18286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18288 
      return
18289 
    iprot.readStructBegin()
18290 
    while True:
18291 
      (fname, ftype, fid) = iprot.readFieldBegin()
18292 
      if ftype == TType.STOP:
18293 
        break
18294 
      if fid == 0:
18295 
        if ftype == TType.LIST:
18296 
          self.success = []
9155 kshitij.so 18297 
          (_etype349, _size346) = iprot.readListBegin()
18298 
          for _i350 in xrange(_size346):
18299 
            _elem351 = ProductNotificationRequest()
18300 
            _elem351.read(iprot)
18301 
            self.success.append(_elem351)
5944 mandeep.dh 18302 
          iprot.readListEnd()
18303 
        else:
18304 
          iprot.skip(ftype)
18305 
      else:
18306 
        iprot.skip(ftype)
18307 
      iprot.readFieldEnd()
18308 
    iprot.readStructEnd()
18309 
 
18310 
  def write(self, oprot):
18311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18313 
      return
18314 
    oprot.writeStructBegin('getProductNotifications_result')
18315 
    if self.success is not None:
18316 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18317 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18318 
      for iter352 in self.success:
18319 
        iter352.write(oprot)
5944 mandeep.dh 18320 
      oprot.writeListEnd()
18321 
      oprot.writeFieldEnd()
18322 
    oprot.writeFieldStop()
18323 
    oprot.writeStructEnd()
18324 
 
18325 
  def validate(self):
18326 
    return
18327 
 
18328 
 
18329 
  def __repr__(self):
18330 
    L = ['%s=%r' % (key, value)
18331 
      for key, value in self.__dict__.iteritems()]
18332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18333 
 
18334 
  def __eq__(self, other):
18335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18336 
 
18337 
  def __ne__(self, other):
18338 
    return not (self == other)
18339 
 
18340 
class getProductNotificationRequestCount_args:
18341 
  """
18342 
  Attributes:
18343 
   - startDateTime
7897 amar.kumar 18344 
   - categoryId
5944 mandeep.dh 18345 
  """
18346 
 
18347 
  thrift_spec = (
18348 
    None, # 0
18349 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 18350 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 18351 
  )
18352 
 
7897 amar.kumar 18353 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 18354 
    self.startDateTime = startDateTime
7897 amar.kumar 18355 
    self.categoryId = categoryId
5944 mandeep.dh 18356 
 
18357 
  def read(self, iprot):
18358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18360 
      return
18361 
    iprot.readStructBegin()
18362 
    while True:
18363 
      (fname, ftype, fid) = iprot.readFieldBegin()
18364 
      if ftype == TType.STOP:
18365 
        break
18366 
      if fid == 1:
18367 
        if ftype == TType.I64:
18368 
          self.startDateTime = iprot.readI64();
18369 
        else:
18370 
          iprot.skip(ftype)
7897 amar.kumar 18371 
      elif fid == 2:
18372 
        if ftype == TType.I64:
18373 
          self.categoryId = iprot.readI64();
18374 
        else:
18375 
          iprot.skip(ftype)
5944 mandeep.dh 18376 
      else:
18377 
        iprot.skip(ftype)
18378 
      iprot.readFieldEnd()
18379 
    iprot.readStructEnd()
18380 
 
18381 
  def write(self, oprot):
18382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18384 
      return
18385 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
18386 
    if self.startDateTime is not None:
18387 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
18388 
      oprot.writeI64(self.startDateTime)
18389 
      oprot.writeFieldEnd()
7897 amar.kumar 18390 
    if self.categoryId is not None:
18391 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
18392 
      oprot.writeI64(self.categoryId)
18393 
      oprot.writeFieldEnd()
5944 mandeep.dh 18394 
    oprot.writeFieldStop()
18395 
    oprot.writeStructEnd()
18396 
 
18397 
  def validate(self):
18398 
    return
18399 
 
18400 
 
18401 
  def __repr__(self):
18402 
    L = ['%s=%r' % (key, value)
18403 
      for key, value in self.__dict__.iteritems()]
18404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18405 
 
18406 
  def __eq__(self, other):
18407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18408 
 
18409 
  def __ne__(self, other):
18410 
    return not (self == other)
18411 
 
18412 
class getProductNotificationRequestCount_result:
18413 
  """
18414 
  Attributes:
18415 
   - success
18416 
  """
18417 
 
18418 
  thrift_spec = (
18419 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
18420 
  )
18421 
 
18422 
  def __init__(self, success=None,):
18423 
    self.success = success
18424 
 
18425 
  def read(self, iprot):
18426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18428 
      return
18429 
    iprot.readStructBegin()
18430 
    while True:
18431 
      (fname, ftype, fid) = iprot.readFieldBegin()
18432 
      if ftype == TType.STOP:
18433 
        break
18434 
      if fid == 0:
18435 
        if ftype == TType.LIST:
18436 
          self.success = []
9155 kshitij.so 18437 
          (_etype356, _size353) = iprot.readListBegin()
18438 
          for _i357 in xrange(_size353):
18439 
            _elem358 = ProductNotificationRequestCount()
18440 
            _elem358.read(iprot)
18441 
            self.success.append(_elem358)
5944 mandeep.dh 18442 
          iprot.readListEnd()
18443 
        else:
18444 
          iprot.skip(ftype)
18445 
      else:
18446 
        iprot.skip(ftype)
18447 
      iprot.readFieldEnd()
18448 
    iprot.readStructEnd()
18449 
 
18450 
  def write(self, oprot):
18451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18453 
      return
18454 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
18455 
    if self.success is not None:
18456 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18457 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18458 
      for iter359 in self.success:
18459 
        iter359.write(oprot)
5944 mandeep.dh 18460 
      oprot.writeListEnd()
18461 
      oprot.writeFieldEnd()
18462 
    oprot.writeFieldStop()
18463 
    oprot.writeStructEnd()
18464 
 
18465 
  def validate(self):
18466 
    return
18467 
 
18468 
 
18469 
  def __repr__(self):
18470 
    L = ['%s=%r' % (key, value)
18471 
      for key, value in self.__dict__.iteritems()]
18472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18473 
 
18474 
  def __eq__(self, other):
18475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18476 
 
18477 
  def __ne__(self, other):
18478 
    return not (self == other)
18479 
 
18480 
class addAuthorizationLog_args:
18481 
  """
18482 
  Attributes:
18483 
   - itemId
18484 
   - username
18485 
   - reason
18486 
  """
18487 
 
18488 
  thrift_spec = (
18489 
    None, # 0
18490 
    (1, TType.I64, 'itemId', None, None, ), # 1
18491 
    (2, TType.STRING, 'username', None, None, ), # 2
18492 
    (3, TType.STRING, 'reason', None, None, ), # 3
18493 
  )
18494 
 
18495 
  def __init__(self, itemId=None, username=None, reason=None,):
18496 
    self.itemId = itemId
18497 
    self.username = username
18498 
    self.reason = reason
18499 
 
18500 
  def read(self, iprot):
18501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18503 
      return
18504 
    iprot.readStructBegin()
18505 
    while True:
18506 
      (fname, ftype, fid) = iprot.readFieldBegin()
18507 
      if ftype == TType.STOP:
18508 
        break
18509 
      if fid == 1:
18510 
        if ftype == TType.I64:
18511 
          self.itemId = iprot.readI64();
18512 
        else:
18513 
          iprot.skip(ftype)
18514 
      elif fid == 2:
18515 
        if ftype == TType.STRING:
18516 
          self.username = iprot.readString();
18517 
        else:
18518 
          iprot.skip(ftype)
18519 
      elif fid == 3:
18520 
        if ftype == TType.STRING:
18521 
          self.reason = iprot.readString();
18522 
        else:
18523 
          iprot.skip(ftype)
18524 
      else:
18525 
        iprot.skip(ftype)
18526 
      iprot.readFieldEnd()
18527 
    iprot.readStructEnd()
18528 
 
18529 
  def write(self, oprot):
18530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18532 
      return
18533 
    oprot.writeStructBegin('addAuthorizationLog_args')
18534 
    if self.itemId is not None:
18535 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18536 
      oprot.writeI64(self.itemId)
18537 
      oprot.writeFieldEnd()
18538 
    if self.username is not None:
18539 
      oprot.writeFieldBegin('username', TType.STRING, 2)
18540 
      oprot.writeString(self.username)
18541 
      oprot.writeFieldEnd()
18542 
    if self.reason is not None:
18543 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18544 
      oprot.writeString(self.reason)
18545 
      oprot.writeFieldEnd()
18546 
    oprot.writeFieldStop()
18547 
    oprot.writeStructEnd()
18548 
 
18549 
  def validate(self):
18550 
    return
18551 
 
18552 
 
18553 
  def __repr__(self):
18554 
    L = ['%s=%r' % (key, value)
18555 
      for key, value in self.__dict__.iteritems()]
18556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18557 
 
18558 
  def __eq__(self, other):
18559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18560 
 
18561 
  def __ne__(self, other):
18562 
    return not (self == other)
18563 
 
18564 
class addAuthorizationLog_result:
18565 
  """
18566 
  Attributes:
18567 
   - success
18568 
   - cex
18569 
  """
18570 
 
18571 
  thrift_spec = (
18572 
    (0, TType.BOOL, 'success', None, None, ), # 0
18573 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18574 
  )
18575 
 
18576 
  def __init__(self, success=None, cex=None,):
18577 
    self.success = success
18578 
    self.cex = cex
18579 
 
18580 
  def read(self, iprot):
18581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18583 
      return
18584 
    iprot.readStructBegin()
18585 
    while True:
18586 
      (fname, ftype, fid) = iprot.readFieldBegin()
18587 
      if ftype == TType.STOP:
18588 
        break
18589 
      if fid == 0:
18590 
        if ftype == TType.BOOL:
18591 
          self.success = iprot.readBool();
18592 
        else:
18593 
          iprot.skip(ftype)
18594 
      elif fid == 1:
18595 
        if ftype == TType.STRUCT:
18596 
          self.cex = CatalogServiceException()
18597 
          self.cex.read(iprot)
18598 
        else:
18599 
          iprot.skip(ftype)
18600 
      else:
18601 
        iprot.skip(ftype)
18602 
      iprot.readFieldEnd()
18603 
    iprot.readStructEnd()
18604 
 
18605 
  def write(self, oprot):
18606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18608 
      return
18609 
    oprot.writeStructBegin('addAuthorizationLog_result')
18610 
    if self.success is not None:
18611 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18612 
      oprot.writeBool(self.success)
18613 
      oprot.writeFieldEnd()
18614 
    if self.cex is not None:
18615 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18616 
      self.cex.write(oprot)
18617 
      oprot.writeFieldEnd()
18618 
    oprot.writeFieldStop()
18619 
    oprot.writeStructEnd()
18620 
 
18621 
  def validate(self):
18622 
    return
18623 
 
18624 
 
18625 
  def __repr__(self):
18626 
    L = ['%s=%r' % (key, value)
18627 
      for key, value in self.__dict__.iteritems()]
18628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18629 
 
18630 
  def __eq__(self, other):
18631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18632 
 
18633 
  def __ne__(self, other):
18634 
    return not (self == other)
18635 
 
18636 
class addupdateVoucherForItem_args:
18637 
  """
18638 
  Attributes:
18639 
   - catalog_item_id
18640 
   - voucherType
18641 
   - voucherAmount
18642 
  """
18643 
 
18644 
  thrift_spec = (
18645 
    None, # 0
18646 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18647 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18648 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
18649 
  )
18650 
 
18651 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
18652 
    self.catalog_item_id = catalog_item_id
18653 
    self.voucherType = voucherType
18654 
    self.voucherAmount = voucherAmount
18655 
 
18656 
  def read(self, iprot):
18657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18659 
      return
18660 
    iprot.readStructBegin()
18661 
    while True:
18662 
      (fname, ftype, fid) = iprot.readFieldBegin()
18663 
      if ftype == TType.STOP:
18664 
        break
18665 
      if fid == 1:
18666 
        if ftype == TType.I64:
18667 
          self.catalog_item_id = iprot.readI64();
18668 
        else:
18669 
          iprot.skip(ftype)
18670 
      elif fid == 2:
18671 
        if ftype == TType.I64:
18672 
          self.voucherType = iprot.readI64();
18673 
        else:
18674 
          iprot.skip(ftype)
18675 
      elif fid == 3:
18676 
        if ftype == TType.I64:
18677 
          self.voucherAmount = iprot.readI64();
18678 
        else:
18679 
          iprot.skip(ftype)
18680 
      else:
18681 
        iprot.skip(ftype)
18682 
      iprot.readFieldEnd()
18683 
    iprot.readStructEnd()
18684 
 
18685 
  def write(self, oprot):
18686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18688 
      return
18689 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
18690 
    if self.catalog_item_id is not None:
18691 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18692 
      oprot.writeI64(self.catalog_item_id)
18693 
      oprot.writeFieldEnd()
18694 
    if self.voucherType is not None:
18695 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18696 
      oprot.writeI64(self.voucherType)
18697 
      oprot.writeFieldEnd()
18698 
    if self.voucherAmount is not None:
18699 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
18700 
      oprot.writeI64(self.voucherAmount)
18701 
      oprot.writeFieldEnd()
18702 
    oprot.writeFieldStop()
18703 
    oprot.writeStructEnd()
18704 
 
18705 
  def validate(self):
18706 
    return
18707 
 
18708 
 
18709 
  def __repr__(self):
18710 
    L = ['%s=%r' % (key, value)
18711 
      for key, value in self.__dict__.iteritems()]
18712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18713 
 
18714 
  def __eq__(self, other):
18715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18716 
 
18717 
  def __ne__(self, other):
18718 
    return not (self == other)
18719 
 
18720 
class addupdateVoucherForItem_result:
18721 
  """
18722 
  Attributes:
18723 
   - success
18724 
   - cex
18725 
  """
18726 
 
18727 
  thrift_spec = (
18728 
    (0, TType.BOOL, 'success', None, None, ), # 0
18729 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18730 
  )
18731 
 
18732 
  def __init__(self, success=None, cex=None,):
18733 
    self.success = success
18734 
    self.cex = cex
18735 
 
18736 
  def read(self, iprot):
18737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18739 
      return
18740 
    iprot.readStructBegin()
18741 
    while True:
18742 
      (fname, ftype, fid) = iprot.readFieldBegin()
18743 
      if ftype == TType.STOP:
18744 
        break
18745 
      if fid == 0:
18746 
        if ftype == TType.BOOL:
18747 
          self.success = iprot.readBool();
18748 
        else:
18749 
          iprot.skip(ftype)
18750 
      elif fid == 1:
18751 
        if ftype == TType.STRUCT:
18752 
          self.cex = CatalogServiceException()
18753 
          self.cex.read(iprot)
18754 
        else:
18755 
          iprot.skip(ftype)
18756 
      else:
18757 
        iprot.skip(ftype)
18758 
      iprot.readFieldEnd()
18759 
    iprot.readStructEnd()
18760 
 
18761 
  def write(self, oprot):
18762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18764 
      return
18765 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
18766 
    if self.success is not None:
18767 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18768 
      oprot.writeBool(self.success)
18769 
      oprot.writeFieldEnd()
18770 
    if self.cex is not None:
18771 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18772 
      self.cex.write(oprot)
18773 
      oprot.writeFieldEnd()
18774 
    oprot.writeFieldStop()
18775 
    oprot.writeStructEnd()
18776 
 
18777 
  def validate(self):
18778 
    return
18779 
 
18780 
 
18781 
  def __repr__(self):
18782 
    L = ['%s=%r' % (key, value)
18783 
      for key, value in self.__dict__.iteritems()]
18784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18785 
 
18786 
  def __eq__(self, other):
18787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18788 
 
18789 
  def __ne__(self, other):
18790 
    return not (self == other)
18791 
 
18792 
class deleteVoucherForItem_args:
18793 
  """
18794 
  Attributes:
18795 
   - catalog_item_id
18796 
   - voucherType
18797 
  """
18798 
 
18799 
  thrift_spec = (
18800 
    None, # 0
18801 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18802 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18803 
  )
18804 
 
18805 
  def __init__(self, catalog_item_id=None, voucherType=None,):
18806 
    self.catalog_item_id = catalog_item_id
18807 
    self.voucherType = voucherType
18808 
 
18809 
  def read(self, iprot):
18810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18812 
      return
18813 
    iprot.readStructBegin()
18814 
    while True:
18815 
      (fname, ftype, fid) = iprot.readFieldBegin()
18816 
      if ftype == TType.STOP:
18817 
        break
18818 
      if fid == 1:
18819 
        if ftype == TType.I64:
18820 
          self.catalog_item_id = iprot.readI64();
18821 
        else:
18822 
          iprot.skip(ftype)
18823 
      elif fid == 2:
18824 
        if ftype == TType.I64:
18825 
          self.voucherType = iprot.readI64();
18826 
        else:
18827 
          iprot.skip(ftype)
18828 
      else:
18829 
        iprot.skip(ftype)
18830 
      iprot.readFieldEnd()
18831 
    iprot.readStructEnd()
18832 
 
18833 
  def write(self, oprot):
18834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18836 
      return
18837 
    oprot.writeStructBegin('deleteVoucherForItem_args')
18838 
    if self.catalog_item_id is not None:
18839 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18840 
      oprot.writeI64(self.catalog_item_id)
18841 
      oprot.writeFieldEnd()
18842 
    if self.voucherType is not None:
18843 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18844 
      oprot.writeI64(self.voucherType)
18845 
      oprot.writeFieldEnd()
18846 
    oprot.writeFieldStop()
18847 
    oprot.writeStructEnd()
18848 
 
18849 
  def validate(self):
18850 
    return
18851 
 
18852 
 
18853 
  def __repr__(self):
18854 
    L = ['%s=%r' % (key, value)
18855 
      for key, value in self.__dict__.iteritems()]
18856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18857 
 
18858 
  def __eq__(self, other):
18859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18860 
 
18861 
  def __ne__(self, other):
18862 
    return not (self == other)
18863 
 
18864 
class deleteVoucherForItem_result:
18865 
  """
18866 
  Attributes:
18867 
   - success
18868 
   - cex
18869 
  """
18870 
 
18871 
  thrift_spec = (
18872 
    (0, TType.BOOL, 'success', None, None, ), # 0
18873 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18874 
  )
18875 
 
18876 
  def __init__(self, success=None, cex=None,):
18877 
    self.success = success
18878 
    self.cex = cex
18879 
 
18880 
  def read(self, iprot):
18881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18883 
      return
18884 
    iprot.readStructBegin()
18885 
    while True:
18886 
      (fname, ftype, fid) = iprot.readFieldBegin()
18887 
      if ftype == TType.STOP:
18888 
        break
18889 
      if fid == 0:
18890 
        if ftype == TType.BOOL:
18891 
          self.success = iprot.readBool();
18892 
        else:
18893 
          iprot.skip(ftype)
18894 
      elif fid == 1:
18895 
        if ftype == TType.STRUCT:
18896 
          self.cex = CatalogServiceException()
18897 
          self.cex.read(iprot)
18898 
        else:
18899 
          iprot.skip(ftype)
18900 
      else:
18901 
        iprot.skip(ftype)
18902 
      iprot.readFieldEnd()
18903 
    iprot.readStructEnd()
18904 
 
18905 
  def write(self, oprot):
18906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18908 
      return
18909 
    oprot.writeStructBegin('deleteVoucherForItem_result')
18910 
    if self.success is not None:
18911 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18912 
      oprot.writeBool(self.success)
18913 
      oprot.writeFieldEnd()
18914 
    if self.cex is not None:
18915 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18916 
      self.cex.write(oprot)
18917 
      oprot.writeFieldEnd()
18918 
    oprot.writeFieldStop()
18919 
    oprot.writeStructEnd()
18920 
 
18921 
  def validate(self):
18922 
    return
18923 
 
18924 
 
18925 
  def __repr__(self):
18926 
    L = ['%s=%r' % (key, value)
18927 
      for key, value in self.__dict__.iteritems()]
18928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18929 
 
18930 
  def __eq__(self, other):
18931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18932 
 
18933 
  def __ne__(self, other):
18934 
    return not (self == other)
18935 
 
18936 
class getVoucherAmount_args:
18937 
  """
18938 
  Attributes:
18939 
   - itemId
18940 
   - voucherType
18941 
  """
18942 
 
18943 
  thrift_spec = (
18944 
    None, # 0
18945 
    (1, TType.I64, 'itemId', None, None, ), # 1
18946 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18947 
  )
18948 
 
18949 
  def __init__(self, itemId=None, voucherType=None,):
18950 
    self.itemId = itemId
18951 
    self.voucherType = voucherType
18952 
 
18953 
  def read(self, iprot):
18954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18956 
      return
18957 
    iprot.readStructBegin()
18958 
    while True:
18959 
      (fname, ftype, fid) = iprot.readFieldBegin()
18960 
      if ftype == TType.STOP:
18961 
        break
18962 
      if fid == 1:
18963 
        if ftype == TType.I64:
18964 
          self.itemId = iprot.readI64();
18965 
        else:
18966 
          iprot.skip(ftype)
18967 
      elif fid == 2:
18968 
        if ftype == TType.I64:
18969 
          self.voucherType = iprot.readI64();
18970 
        else:
18971 
          iprot.skip(ftype)
18972 
      else:
18973 
        iprot.skip(ftype)
18974 
      iprot.readFieldEnd()
18975 
    iprot.readStructEnd()
18976 
 
18977 
  def write(self, oprot):
18978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18980 
      return
18981 
    oprot.writeStructBegin('getVoucherAmount_args')
18982 
    if self.itemId is not None:
18983 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18984 
      oprot.writeI64(self.itemId)
18985 
      oprot.writeFieldEnd()
18986 
    if self.voucherType is not None:
18987 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18988 
      oprot.writeI64(self.voucherType)
18989 
      oprot.writeFieldEnd()
18990 
    oprot.writeFieldStop()
18991 
    oprot.writeStructEnd()
18992 
 
18993 
  def validate(self):
18994 
    return
18995 
 
18996 
 
18997 
  def __repr__(self):
18998 
    L = ['%s=%r' % (key, value)
18999 
      for key, value in self.__dict__.iteritems()]
19000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19001 
 
19002 
  def __eq__(self, other):
19003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19004 
 
19005 
  def __ne__(self, other):
19006 
    return not (self == other)
19007 
 
19008 
class getVoucherAmount_result:
19009 
  """
19010 
  Attributes:
19011 
   - success
19012 
  """
19013 
 
19014 
  thrift_spec = (
19015 
    (0, TType.I64, 'success', None, None, ), # 0
19016 
  )
19017 
 
19018 
  def __init__(self, success=None,):
19019 
    self.success = success
19020 
 
19021 
  def read(self, iprot):
19022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19024 
      return
19025 
    iprot.readStructBegin()
19026 
    while True:
19027 
      (fname, ftype, fid) = iprot.readFieldBegin()
19028 
      if ftype == TType.STOP:
19029 
        break
19030 
      if fid == 0:
19031 
        if ftype == TType.I64:
19032 
          self.success = iprot.readI64();
19033 
        else:
19034 
          iprot.skip(ftype)
19035 
      else:
19036 
        iprot.skip(ftype)
19037 
      iprot.readFieldEnd()
19038 
    iprot.readStructEnd()
19039 
 
19040 
  def write(self, oprot):
19041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19043 
      return
19044 
    oprot.writeStructBegin('getVoucherAmount_result')
19045 
    if self.success is not None:
19046 
      oprot.writeFieldBegin('success', TType.I64, 0)
19047 
      oprot.writeI64(self.success)
19048 
      oprot.writeFieldEnd()
19049 
    oprot.writeFieldStop()
19050 
    oprot.writeStructEnd()
19051 
 
19052 
  def validate(self):
19053 
    return
19054 
 
19055 
 
19056 
  def __repr__(self):
19057 
    L = ['%s=%r' % (key, value)
19058 
      for key, value in self.__dict__.iteritems()]
19059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19060 
 
19061 
  def __eq__(self, other):
19062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19063 
 
19064 
  def __ne__(self, other):
19065 
    return not (self == other)
19066 
 
19067 
class getAllItemVouchers_args:
19068 
  """
19069 
  Attributes:
19070 
   - itemId
19071 
  """
19072 
 
19073 
  thrift_spec = (
19074 
    None, # 0
19075 
    (1, TType.I64, 'itemId', None, None, ), # 1
19076 
  )
19077 
 
19078 
  def __init__(self, itemId=None,):
19079 
    self.itemId = itemId
19080 
 
19081 
  def read(self, iprot):
19082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19084 
      return
19085 
    iprot.readStructBegin()
19086 
    while True:
19087 
      (fname, ftype, fid) = iprot.readFieldBegin()
19088 
      if ftype == TType.STOP:
19089 
        break
19090 
      if fid == 1:
19091 
        if ftype == TType.I64:
19092 
          self.itemId = iprot.readI64();
19093 
        else:
19094 
          iprot.skip(ftype)
19095 
      else:
19096 
        iprot.skip(ftype)
19097 
      iprot.readFieldEnd()
19098 
    iprot.readStructEnd()
19099 
 
19100 
  def write(self, oprot):
19101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19103 
      return
19104 
    oprot.writeStructBegin('getAllItemVouchers_args')
19105 
    if self.itemId is not None:
19106 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19107 
      oprot.writeI64(self.itemId)
19108 
      oprot.writeFieldEnd()
19109 
    oprot.writeFieldStop()
19110 
    oprot.writeStructEnd()
19111 
 
19112 
  def validate(self):
19113 
    return
19114 
 
19115 
 
19116 
  def __repr__(self):
19117 
    L = ['%s=%r' % (key, value)
19118 
      for key, value in self.__dict__.iteritems()]
19119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19120 
 
19121 
  def __eq__(self, other):
19122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19123 
 
19124 
  def __ne__(self, other):
19125 
    return not (self == other)
19126 
 
19127 
class getAllItemVouchers_result:
19128 
  """
19129 
  Attributes:
19130 
   - success
19131 
  """
19132 
 
19133 
  thrift_spec = (
19134 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
19135 
  )
19136 
 
19137 
  def __init__(self, success=None,):
19138 
    self.success = success
19139 
 
19140 
  def read(self, iprot):
19141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19143 
      return
19144 
    iprot.readStructBegin()
19145 
    while True:
19146 
      (fname, ftype, fid) = iprot.readFieldBegin()
19147 
      if ftype == TType.STOP:
19148 
        break
19149 
      if fid == 0:
19150 
        if ftype == TType.LIST:
19151 
          self.success = []
9155 kshitij.so 19152 
          (_etype363, _size360) = iprot.readListBegin()
19153 
          for _i364 in xrange(_size360):
19154 
            _elem365 = VoucherItemMapping()
19155 
            _elem365.read(iprot)
19156 
            self.success.append(_elem365)
5944 mandeep.dh 19157 
          iprot.readListEnd()
19158 
        else:
19159 
          iprot.skip(ftype)
19160 
      else:
19161 
        iprot.skip(ftype)
19162 
      iprot.readFieldEnd()
19163 
    iprot.readStructEnd()
19164 
 
19165 
  def write(self, oprot):
19166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19168 
      return
19169 
    oprot.writeStructBegin('getAllItemVouchers_result')
19170 
    if self.success is not None:
19171 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19172 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19173 
      for iter366 in self.success:
19174 
        iter366.write(oprot)
5944 mandeep.dh 19175 
      oprot.writeListEnd()
19176 
      oprot.writeFieldEnd()
19177 
    oprot.writeFieldStop()
19178 
    oprot.writeStructEnd()
19179 
 
19180 
  def validate(self):
19181 
    return
19182 
 
19183 
 
19184 
  def __repr__(self):
19185 
    L = ['%s=%r' % (key, value)
19186 
      for key, value in self.__dict__.iteritems()]
19187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19188 
 
19189 
  def __eq__(self, other):
19190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19191 
 
19192 
  def __ne__(self, other):
19193 
    return not (self == other)
19194 
 
19195 
class isValidCatalogItemId_args:
19196 
  """
19197 
  Attributes:
19198 
   - catalog_item_id
19199 
  """
19200 
 
19201 
  thrift_spec = (
19202 
    None, # 0
19203 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
19204 
  )
19205 
 
19206 
  def __init__(self, catalog_item_id=None,):
19207 
    self.catalog_item_id = catalog_item_id
19208 
 
19209 
  def read(self, iprot):
19210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19212 
      return
19213 
    iprot.readStructBegin()
19214 
    while True:
19215 
      (fname, ftype, fid) = iprot.readFieldBegin()
19216 
      if ftype == TType.STOP:
19217 
        break
19218 
      if fid == 1:
19219 
        if ftype == TType.I64:
19220 
          self.catalog_item_id = iprot.readI64();
19221 
        else:
19222 
          iprot.skip(ftype)
19223 
      else:
19224 
        iprot.skip(ftype)
19225 
      iprot.readFieldEnd()
19226 
    iprot.readStructEnd()
19227 
 
19228 
  def write(self, oprot):
19229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19231 
      return
19232 
    oprot.writeStructBegin('isValidCatalogItemId_args')
19233 
    if self.catalog_item_id is not None:
19234 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
19235 
      oprot.writeI64(self.catalog_item_id)
19236 
      oprot.writeFieldEnd()
19237 
    oprot.writeFieldStop()
19238 
    oprot.writeStructEnd()
19239 
 
19240 
  def validate(self):
19241 
    return
19242 
 
19243 
 
19244 
  def __repr__(self):
19245 
    L = ['%s=%r' % (key, value)
19246 
      for key, value in self.__dict__.iteritems()]
19247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19248 
 
19249 
  def __eq__(self, other):
19250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19251 
 
19252 
  def __ne__(self, other):
19253 
    return not (self == other)
19254 
 
19255 
class isValidCatalogItemId_result:
19256 
  """
19257 
  Attributes:
19258 
   - success
19259 
  """
19260 
 
19261 
  thrift_spec = (
19262 
    (0, TType.BOOL, 'success', None, None, ), # 0
19263 
  )
19264 
 
19265 
  def __init__(self, success=None,):
19266 
    self.success = success
19267 
 
19268 
  def read(self, iprot):
19269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19271 
      return
19272 
    iprot.readStructBegin()
19273 
    while True:
19274 
      (fname, ftype, fid) = iprot.readFieldBegin()
19275 
      if ftype == TType.STOP:
19276 
        break
19277 
      if fid == 0:
19278 
        if ftype == TType.BOOL:
19279 
          self.success = iprot.readBool();
19280 
        else:
19281 
          iprot.skip(ftype)
19282 
      else:
19283 
        iprot.skip(ftype)
19284 
      iprot.readFieldEnd()
19285 
    iprot.readStructEnd()
19286 
 
19287 
  def write(self, oprot):
19288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19290 
      return
19291 
    oprot.writeStructBegin('isValidCatalogItemId_result')
19292 
    if self.success is not None:
19293 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19294 
      oprot.writeBool(self.success)
19295 
      oprot.writeFieldEnd()
19296 
    oprot.writeFieldStop()
19297 
    oprot.writeStructEnd()
19298 
 
19299 
  def validate(self):
19300 
    return
19301 
 
19302 
 
19303 
  def __repr__(self):
19304 
    L = ['%s=%r' % (key, value)
19305 
      for key, value in self.__dict__.iteritems()]
19306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19307 
 
19308 
  def __eq__(self, other):
19309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19310 
 
19311 
  def __ne__(self, other):
19312 
    return not (self == other)
6039 amit.gupta 19313 
 
19314 
class getVatPercentageForItem_args:
19315 
  """
19316 
  Attributes:
19317 
   - itemId
7330 amit.gupta 19318 
   - stateId
6039 amit.gupta 19319 
   - price
19320 
  """
19321 
 
19322 
  thrift_spec = (
19323 
    None, # 0
19324 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 19325 
    (2, TType.I64, 'stateId', None, None, ), # 2
19326 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 19327 
  )
19328 
 
7330 amit.gupta 19329 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 19330 
    self.itemId = itemId
7330 amit.gupta 19331 
    self.stateId = stateId
6039 amit.gupta 19332 
    self.price = price
19333 
 
19334 
  def read(self, iprot):
19335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19337 
      return
19338 
    iprot.readStructBegin()
19339 
    while True:
19340 
      (fname, ftype, fid) = iprot.readFieldBegin()
19341 
      if ftype == TType.STOP:
19342 
        break
19343 
      if fid == 1:
19344 
        if ftype == TType.I64:
19345 
          self.itemId = iprot.readI64();
19346 
        else:
19347 
          iprot.skip(ftype)
19348 
      elif fid == 2:
7330 amit.gupta 19349 
        if ftype == TType.I64:
19350 
          self.stateId = iprot.readI64();
19351 
        else:
19352 
          iprot.skip(ftype)
19353 
      elif fid == 3:
6039 amit.gupta 19354 
        if ftype == TType.DOUBLE:
19355 
          self.price = iprot.readDouble();
19356 
        else:
19357 
          iprot.skip(ftype)
19358 
      else:
19359 
        iprot.skip(ftype)
19360 
      iprot.readFieldEnd()
19361 
    iprot.readStructEnd()
19362 
 
19363 
  def write(self, oprot):
19364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19366 
      return
19367 
    oprot.writeStructBegin('getVatPercentageForItem_args')
19368 
    if self.itemId is not None:
19369 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19370 
      oprot.writeI64(self.itemId)
19371 
      oprot.writeFieldEnd()
7330 amit.gupta 19372 
    if self.stateId is not None:
19373 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
19374 
      oprot.writeI64(self.stateId)
19375 
      oprot.writeFieldEnd()
6039 amit.gupta 19376 
    if self.price is not None:
7330 amit.gupta 19377 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 19378 
      oprot.writeDouble(self.price)
19379 
      oprot.writeFieldEnd()
19380 
    oprot.writeFieldStop()
19381 
    oprot.writeStructEnd()
19382 
 
19383 
  def validate(self):
19384 
    return
19385 
 
19386 
 
19387 
  def __repr__(self):
19388 
    L = ['%s=%r' % (key, value)
19389 
      for key, value in self.__dict__.iteritems()]
19390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19391 
 
19392 
  def __eq__(self, other):
19393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19394 
 
19395 
  def __ne__(self, other):
19396 
    return not (self == other)
19397 
 
19398 
class getVatPercentageForItem_result:
19399 
  """
19400 
  Attributes:
19401 
   - success
7340 amit.gupta 19402 
   - cex
6039 amit.gupta 19403 
  """
19404 
 
19405 
  thrift_spec = (
19406 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 19407 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 19408 
  )
19409 
 
7340 amit.gupta 19410 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 19411 
    self.success = success
7340 amit.gupta 19412 
    self.cex = cex
6039 amit.gupta 19413 
 
19414 
  def read(self, iprot):
19415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19417 
      return
19418 
    iprot.readStructBegin()
19419 
    while True:
19420 
      (fname, ftype, fid) = iprot.readFieldBegin()
19421 
      if ftype == TType.STOP:
19422 
        break
19423 
      if fid == 0:
19424 
        if ftype == TType.DOUBLE:
19425 
          self.success = iprot.readDouble();
19426 
        else:
19427 
          iprot.skip(ftype)
7340 amit.gupta 19428 
      elif fid == 1:
19429 
        if ftype == TType.STRUCT:
19430 
          self.cex = CatalogServiceException()
19431 
          self.cex.read(iprot)
19432 
        else:
19433 
          iprot.skip(ftype)
6039 amit.gupta 19434 
      else:
19435 
        iprot.skip(ftype)
19436 
      iprot.readFieldEnd()
19437 
    iprot.readStructEnd()
19438 
 
19439 
  def write(self, oprot):
19440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19442 
      return
19443 
    oprot.writeStructBegin('getVatPercentageForItem_result')
19444 
    if self.success is not None:
19445 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
19446 
      oprot.writeDouble(self.success)
19447 
      oprot.writeFieldEnd()
7340 amit.gupta 19448 
    if self.cex is not None:
19449 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19450 
      self.cex.write(oprot)
19451 
      oprot.writeFieldEnd()
6039 amit.gupta 19452 
    oprot.writeFieldStop()
19453 
    oprot.writeStructEnd()
19454 
 
19455 
  def validate(self):
19456 
    return
19457 
 
19458 
 
19459 
  def __repr__(self):
19460 
    L = ['%s=%r' % (key, value)
19461 
      for key, value in self.__dict__.iteritems()]
19462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19463 
 
19464 
  def __eq__(self, other):
19465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19466 
 
19467 
  def __ne__(self, other):
19468 
    return not (self == other)
19469 
 
19470 
class getVatAmountForItem_args:
19471 
  """
19472 
  Attributes:
19473 
   - itemId
19474 
   - price
19475 
  """
19476 
 
19477 
  thrift_spec = (
19478 
    None, # 0
19479 
    (1, TType.I64, 'itemId', None, None, ), # 1
19480 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
19481 
  )
19482 
 
19483 
  def __init__(self, itemId=None, price=None,):
19484 
    self.itemId = itemId
19485 
    self.price = price
19486 
 
19487 
  def read(self, iprot):
19488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19490 
      return
19491 
    iprot.readStructBegin()
19492 
    while True:
19493 
      (fname, ftype, fid) = iprot.readFieldBegin()
19494 
      if ftype == TType.STOP:
19495 
        break
19496 
      if fid == 1:
19497 
        if ftype == TType.I64:
19498 
          self.itemId = iprot.readI64();
19499 
        else:
19500 
          iprot.skip(ftype)
19501 
      elif fid == 2:
19502 
        if ftype == TType.DOUBLE:
19503 
          self.price = iprot.readDouble();
19504 
        else:
19505 
          iprot.skip(ftype)
19506 
      else:
19507 
        iprot.skip(ftype)
19508 
      iprot.readFieldEnd()
19509 
    iprot.readStructEnd()
19510 
 
19511 
  def write(self, oprot):
19512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19514 
      return
19515 
    oprot.writeStructBegin('getVatAmountForItem_args')
19516 
    if self.itemId is not None:
19517 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19518 
      oprot.writeI64(self.itemId)
19519 
      oprot.writeFieldEnd()
19520 
    if self.price is not None:
19521 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
19522 
      oprot.writeDouble(self.price)
19523 
      oprot.writeFieldEnd()
19524 
    oprot.writeFieldStop()
19525 
    oprot.writeStructEnd()
19526 
 
19527 
  def validate(self):
19528 
    return
19529 
 
19530 
 
19531 
  def __repr__(self):
19532 
    L = ['%s=%r' % (key, value)
19533 
      for key, value in self.__dict__.iteritems()]
19534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19535 
 
19536 
  def __eq__(self, other):
19537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19538 
 
19539 
  def __ne__(self, other):
19540 
    return not (self == other)
19541 
 
19542 
class getVatAmountForItem_result:
19543 
  """
19544 
  Attributes:
19545 
   - success
19546 
  """
19547 
 
19548 
  thrift_spec = (
19549 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
19550 
  )
19551 
 
19552 
  def __init__(self, success=None,):
19553 
    self.success = success
19554 
 
19555 
  def read(self, iprot):
19556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19558 
      return
19559 
    iprot.readStructBegin()
19560 
    while True:
19561 
      (fname, ftype, fid) = iprot.readFieldBegin()
19562 
      if ftype == TType.STOP:
19563 
        break
19564 
      if fid == 0:
19565 
        if ftype == TType.DOUBLE:
19566 
          self.success = iprot.readDouble();
19567 
        else:
19568 
          iprot.skip(ftype)
19569 
      else:
19570 
        iprot.skip(ftype)
19571 
      iprot.readFieldEnd()
19572 
    iprot.readStructEnd()
19573 
 
19574 
  def write(self, oprot):
19575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19577 
      return
19578 
    oprot.writeStructBegin('getVatAmountForItem_result')
19579 
    if self.success is not None:
19580 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
19581 
      oprot.writeDouble(self.success)
19582 
      oprot.writeFieldEnd()
19583 
    oprot.writeFieldStop()
19584 
    oprot.writeStructEnd()
19585 
 
19586 
  def validate(self):
19587 
    return
19588 
 
19589 
 
19590 
  def __repr__(self):
19591 
    L = ['%s=%r' % (key, value)
19592 
      for key, value in self.__dict__.iteritems()]
19593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19594 
 
19595 
  def __eq__(self, other):
19596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19597 
 
19598 
  def __ne__(self, other):
19599 
    return not (self == other)
6531 vikram.rag 19600 
 
19601 
class getAllIgnoredInventoryUpdateItemsList_args:
19602 
  """
19603 
  Attributes:
19604 
   - offset
19605 
   - limit
19606 
  """
19607 
 
19608 
  thrift_spec = (
19609 
    None, # 0
19610 
    (1, TType.I32, 'offset', None, None, ), # 1
19611 
    (2, TType.I32, 'limit', None, None, ), # 2
19612 
  )
19613 
 
19614 
  def __init__(self, offset=None, limit=None,):
19615 
    self.offset = offset
19616 
    self.limit = limit
19617 
 
19618 
  def read(self, iprot):
19619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19621 
      return
19622 
    iprot.readStructBegin()
19623 
    while True:
19624 
      (fname, ftype, fid) = iprot.readFieldBegin()
19625 
      if ftype == TType.STOP:
19626 
        break
19627 
      if fid == 1:
19628 
        if ftype == TType.I32:
19629 
          self.offset = iprot.readI32();
19630 
        else:
19631 
          iprot.skip(ftype)
19632 
      elif fid == 2:
19633 
        if ftype == TType.I32:
19634 
          self.limit = iprot.readI32();
19635 
        else:
19636 
          iprot.skip(ftype)
19637 
      else:
19638 
        iprot.skip(ftype)
19639 
      iprot.readFieldEnd()
19640 
    iprot.readStructEnd()
19641 
 
19642 
  def write(self, oprot):
19643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19645 
      return
19646 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
19647 
    if self.offset is not None:
19648 
      oprot.writeFieldBegin('offset', TType.I32, 1)
19649 
      oprot.writeI32(self.offset)
19650 
      oprot.writeFieldEnd()
19651 
    if self.limit is not None:
19652 
      oprot.writeFieldBegin('limit', TType.I32, 2)
19653 
      oprot.writeI32(self.limit)
19654 
      oprot.writeFieldEnd()
19655 
    oprot.writeFieldStop()
19656 
    oprot.writeStructEnd()
19657 
 
19658 
  def validate(self):
19659 
    return
19660 
 
19661 
 
19662 
  def __repr__(self):
19663 
    L = ['%s=%r' % (key, value)
19664 
      for key, value in self.__dict__.iteritems()]
19665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19666 
 
19667 
  def __eq__(self, other):
19668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19669 
 
19670 
  def __ne__(self, other):
19671 
    return not (self == other)
19672 
 
19673 
class getAllIgnoredInventoryUpdateItemsList_result:
19674 
  """
19675 
  Attributes:
19676 
   - success
19677 
  """
19678 
 
19679 
  thrift_spec = (
19680 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19681 
  )
19682 
 
19683 
  def __init__(self, success=None,):
19684 
    self.success = success
19685 
 
19686 
  def read(self, iprot):
19687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19689 
      return
19690 
    iprot.readStructBegin()
19691 
    while True:
19692 
      (fname, ftype, fid) = iprot.readFieldBegin()
19693 
      if ftype == TType.STOP:
19694 
        break
19695 
      if fid == 0:
19696 
        if ftype == TType.LIST:
19697 
          self.success = []
9155 kshitij.so 19698 
          (_etype370, _size367) = iprot.readListBegin()
19699 
          for _i371 in xrange(_size367):
19700 
            _elem372 = Item()
19701 
            _elem372.read(iprot)
19702 
            self.success.append(_elem372)
6531 vikram.rag 19703 
          iprot.readListEnd()
19704 
        else:
19705 
          iprot.skip(ftype)
19706 
      else:
19707 
        iprot.skip(ftype)
19708 
      iprot.readFieldEnd()
19709 
    iprot.readStructEnd()
19710 
 
19711 
  def write(self, oprot):
19712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19714 
      return
19715 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
19716 
    if self.success is not None:
19717 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19718 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19719 
      for iter373 in self.success:
19720 
        iter373.write(oprot)
6531 vikram.rag 19721 
      oprot.writeListEnd()
19722 
      oprot.writeFieldEnd()
19723 
    oprot.writeFieldStop()
19724 
    oprot.writeStructEnd()
19725 
 
19726 
  def validate(self):
19727 
    return
19728 
 
19729 
 
19730 
  def __repr__(self):
19731 
    L = ['%s=%r' % (key, value)
19732 
      for key, value in self.__dict__.iteritems()]
19733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19734 
 
19735 
  def __eq__(self, other):
19736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19737 
 
19738 
  def __ne__(self, other):
19739 
    return not (self == other)
6805 anupam.sin 19740 
 
6821 amar.kumar 19741 
class getAllAliveItems_args:
19742 
 
19743 
  thrift_spec = (
19744 
  )
19745 
 
19746 
  def read(self, iprot):
19747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19749 
      return
19750 
    iprot.readStructBegin()
19751 
    while True:
19752 
      (fname, ftype, fid) = iprot.readFieldBegin()
19753 
      if ftype == TType.STOP:
19754 
        break
19755 
      else:
19756 
        iprot.skip(ftype)
19757 
      iprot.readFieldEnd()
19758 
    iprot.readStructEnd()
19759 
 
19760 
  def write(self, oprot):
19761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19763 
      return
19764 
    oprot.writeStructBegin('getAllAliveItems_args')
19765 
    oprot.writeFieldStop()
19766 
    oprot.writeStructEnd()
19767 
 
19768 
  def validate(self):
19769 
    return
19770 
 
19771 
 
19772 
  def __repr__(self):
19773 
    L = ['%s=%r' % (key, value)
19774 
      for key, value in self.__dict__.iteritems()]
19775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19776 
 
19777 
  def __eq__(self, other):
19778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19779 
 
19780 
  def __ne__(self, other):
19781 
    return not (self == other)
19782 
 
19783 
class getAllAliveItems_result:
19784 
  """
19785 
  Attributes:
19786 
   - success
19787 
  """
19788 
 
19789 
  thrift_spec = (
19790 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19791 
  )
19792 
 
19793 
  def __init__(self, success=None,):
19794 
    self.success = success
19795 
 
19796 
  def read(self, iprot):
19797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19799 
      return
19800 
    iprot.readStructBegin()
19801 
    while True:
19802 
      (fname, ftype, fid) = iprot.readFieldBegin()
19803 
      if ftype == TType.STOP:
19804 
        break
19805 
      if fid == 0:
19806 
        if ftype == TType.LIST:
19807 
          self.success = []
9155 kshitij.so 19808 
          (_etype377, _size374) = iprot.readListBegin()
19809 
          for _i378 in xrange(_size374):
19810 
            _elem379 = Item()
19811 
            _elem379.read(iprot)
19812 
            self.success.append(_elem379)
6821 amar.kumar 19813 
          iprot.readListEnd()
19814 
        else:
19815 
          iprot.skip(ftype)
19816 
      else:
19817 
        iprot.skip(ftype)
19818 
      iprot.readFieldEnd()
19819 
    iprot.readStructEnd()
19820 
 
19821 
  def write(self, oprot):
19822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19824 
      return
19825 
    oprot.writeStructBegin('getAllAliveItems_result')
19826 
    if self.success is not None:
19827 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19828 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19829 
      for iter380 in self.success:
19830 
        iter380.write(oprot)
6821 amar.kumar 19831 
      oprot.writeListEnd()
19832 
      oprot.writeFieldEnd()
19833 
    oprot.writeFieldStop()
19834 
    oprot.writeStructEnd()
19835 
 
19836 
  def validate(self):
19837 
    return
19838 
 
19839 
 
19840 
  def __repr__(self):
19841 
    L = ['%s=%r' % (key, value)
19842 
      for key, value in self.__dict__.iteritems()]
19843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19844 
 
19845 
  def __eq__(self, other):
19846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19847 
 
19848 
  def __ne__(self, other):
19849 
    return not (self == other)
19850 
 
6805 anupam.sin 19851 
class getInsuranceAmount_args:
19852 
  """
19853 
  Attributes:
19854 
   - itemId
6921 anupam.sin 19855 
   - price
6805 anupam.sin 19856 
   - insurerId
19857 
   - quantity
19858 
  """
19859 
 
19860 
  thrift_spec = (
19861 
    None, # 0
19862 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 19863 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
19864 
    (3, TType.I64, 'insurerId', None, None, ), # 3
19865 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 19866 
  )
19867 
 
6921 anupam.sin 19868 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 19869 
    self.itemId = itemId
6921 anupam.sin 19870 
    self.price = price
6805 anupam.sin 19871 
    self.insurerId = insurerId
19872 
    self.quantity = quantity
19873 
 
19874 
  def read(self, iprot):
19875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19877 
      return
19878 
    iprot.readStructBegin()
19879 
    while True:
19880 
      (fname, ftype, fid) = iprot.readFieldBegin()
19881 
      if ftype == TType.STOP:
19882 
        break
19883 
      if fid == 1:
19884 
        if ftype == TType.I64:
19885 
          self.itemId = iprot.readI64();
19886 
        else:
19887 
          iprot.skip(ftype)
19888 
      elif fid == 2:
6921 anupam.sin 19889 
        if ftype == TType.DOUBLE:
19890 
          self.price = iprot.readDouble();
19891 
        else:
19892 
          iprot.skip(ftype)
19893 
      elif fid == 3:
6805 anupam.sin 19894 
        if ftype == TType.I64:
19895 
          self.insurerId = iprot.readI64();
19896 
        else:
19897 
          iprot.skip(ftype)
6921 anupam.sin 19898 
      elif fid == 4:
6805 anupam.sin 19899 
        if ftype == TType.I64:
19900 
          self.quantity = iprot.readI64();
19901 
        else:
19902 
          iprot.skip(ftype)
19903 
      else:
19904 
        iprot.skip(ftype)
19905 
      iprot.readFieldEnd()
19906 
    iprot.readStructEnd()
19907 
 
19908 
  def write(self, oprot):
19909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19911 
      return
19912 
    oprot.writeStructBegin('getInsuranceAmount_args')
19913 
    if self.itemId is not None:
19914 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19915 
      oprot.writeI64(self.itemId)
19916 
      oprot.writeFieldEnd()
6921 anupam.sin 19917 
    if self.price is not None:
19918 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
19919 
      oprot.writeDouble(self.price)
19920 
      oprot.writeFieldEnd()
6805 anupam.sin 19921 
    if self.insurerId is not None:
6921 anupam.sin 19922 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 19923 
      oprot.writeI64(self.insurerId)
19924 
      oprot.writeFieldEnd()
19925 
    if self.quantity is not None:
6921 anupam.sin 19926 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 19927 
      oprot.writeI64(self.quantity)
19928 
      oprot.writeFieldEnd()
19929 
    oprot.writeFieldStop()
19930 
    oprot.writeStructEnd()
19931 
 
19932 
  def validate(self):
19933 
    return
19934 
 
19935 
 
19936 
  def __repr__(self):
19937 
    L = ['%s=%r' % (key, value)
19938 
      for key, value in self.__dict__.iteritems()]
19939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19940 
 
19941 
  def __eq__(self, other):
19942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19943 
 
19944 
  def __ne__(self, other):
19945 
    return not (self == other)
19946 
 
19947 
class getInsuranceAmount_result:
19948 
  """
19949 
  Attributes:
19950 
   - success
19951 
  """
19952 
 
19953 
  thrift_spec = (
19954 
    (0, TType.I64, 'success', None, None, ), # 0
19955 
  )
19956 
 
19957 
  def __init__(self, success=None,):
19958 
    self.success = success
19959 
 
19960 
  def read(self, iprot):
19961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19963 
      return
19964 
    iprot.readStructBegin()
19965 
    while True:
19966 
      (fname, ftype, fid) = iprot.readFieldBegin()
19967 
      if ftype == TType.STOP:
19968 
        break
19969 
      if fid == 0:
19970 
        if ftype == TType.I64:
19971 
          self.success = iprot.readI64();
19972 
        else:
19973 
          iprot.skip(ftype)
19974 
      else:
19975 
        iprot.skip(ftype)
19976 
      iprot.readFieldEnd()
19977 
    iprot.readStructEnd()
19978 
 
19979 
  def write(self, oprot):
19980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19982 
      return
19983 
    oprot.writeStructBegin('getInsuranceAmount_result')
19984 
    if self.success is not None:
19985 
      oprot.writeFieldBegin('success', TType.I64, 0)
19986 
      oprot.writeI64(self.success)
19987 
      oprot.writeFieldEnd()
19988 
    oprot.writeFieldStop()
19989 
    oprot.writeStructEnd()
19990 
 
19991 
  def validate(self):
19992 
    return
19993 
 
19994 
 
19995 
  def __repr__(self):
19996 
    L = ['%s=%r' % (key, value)
19997 
      for key, value in self.__dict__.iteritems()]
19998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19999 
 
20000 
  def __eq__(self, other):
20001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20002 
 
20003 
  def __ne__(self, other):
20004 
    return not (self == other)
20005 
 
20006 
class getInsurer_args:
20007 
  """
20008 
  Attributes:
20009 
   - insurerId
20010 
  """
20011 
 
20012 
  thrift_spec = (
20013 
    None, # 0
20014 
    (1, TType.I64, 'insurerId', None, None, ), # 1
20015 
  )
20016 
 
20017 
  def __init__(self, insurerId=None,):
20018 
    self.insurerId = insurerId
20019 
 
20020 
  def read(self, iprot):
20021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20023 
      return
20024 
    iprot.readStructBegin()
20025 
    while True:
20026 
      (fname, ftype, fid) = iprot.readFieldBegin()
20027 
      if ftype == TType.STOP:
20028 
        break
20029 
      if fid == 1:
20030 
        if ftype == TType.I64:
20031 
          self.insurerId = iprot.readI64();
20032 
        else:
20033 
          iprot.skip(ftype)
20034 
      else:
20035 
        iprot.skip(ftype)
20036 
      iprot.readFieldEnd()
20037 
    iprot.readStructEnd()
20038 
 
20039 
  def write(self, oprot):
20040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20042 
      return
20043 
    oprot.writeStructBegin('getInsurer_args')
20044 
    if self.insurerId is not None:
20045 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
20046 
      oprot.writeI64(self.insurerId)
20047 
      oprot.writeFieldEnd()
20048 
    oprot.writeFieldStop()
20049 
    oprot.writeStructEnd()
20050 
 
20051 
  def validate(self):
20052 
    return
20053 
 
20054 
 
20055 
  def __repr__(self):
20056 
    L = ['%s=%r' % (key, value)
20057 
      for key, value in self.__dict__.iteritems()]
20058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20059 
 
20060 
  def __eq__(self, other):
20061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20062 
 
20063 
  def __ne__(self, other):
20064 
    return not (self == other)
20065 
 
20066 
class getInsurer_result:
20067 
  """
20068 
  Attributes:
20069 
   - success
20070 
  """
20071 
 
20072 
  thrift_spec = (
20073 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
20074 
  )
20075 
 
20076 
  def __init__(self, success=None,):
20077 
    self.success = success
20078 
 
20079 
  def read(self, iprot):
20080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20082 
      return
20083 
    iprot.readStructBegin()
20084 
    while True:
20085 
      (fname, ftype, fid) = iprot.readFieldBegin()
20086 
      if ftype == TType.STOP:
20087 
        break
20088 
      if fid == 0:
20089 
        if ftype == TType.STRUCT:
20090 
          self.success = Insurer()
20091 
          self.success.read(iprot)
20092 
        else:
20093 
          iprot.skip(ftype)
20094 
      else:
20095 
        iprot.skip(ftype)
20096 
      iprot.readFieldEnd()
20097 
    iprot.readStructEnd()
20098 
 
20099 
  def write(self, oprot):
20100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20102 
      return
20103 
    oprot.writeStructBegin('getInsurer_result')
20104 
    if self.success is not None:
20105 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20106 
      self.success.write(oprot)
20107 
      oprot.writeFieldEnd()
20108 
    oprot.writeFieldStop()
20109 
    oprot.writeStructEnd()
20110 
 
20111 
  def validate(self):
20112 
    return
20113 
 
20114 
 
20115 
  def __repr__(self):
20116 
    L = ['%s=%r' % (key, value)
20117 
      for key, value in self.__dict__.iteritems()]
20118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20119 
 
20120 
  def __eq__(self, other):
20121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20122 
 
20123 
  def __ne__(self, other):
20124 
    return not (self == other)
6838 vikram.rag 20125 
 
20126 
class getAllInsurers_args:
20127 
 
20128 
  thrift_spec = (
20129 
  )
20130 
 
20131 
  def read(self, iprot):
20132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20134 
      return
20135 
    iprot.readStructBegin()
20136 
    while True:
20137 
      (fname, ftype, fid) = iprot.readFieldBegin()
20138 
      if ftype == TType.STOP:
20139 
        break
20140 
      else:
20141 
        iprot.skip(ftype)
20142 
      iprot.readFieldEnd()
20143 
    iprot.readStructEnd()
20144 
 
20145 
  def write(self, oprot):
20146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20148 
      return
20149 
    oprot.writeStructBegin('getAllInsurers_args')
20150 
    oprot.writeFieldStop()
20151 
    oprot.writeStructEnd()
20152 
 
20153 
  def validate(self):
20154 
    return
20155 
 
20156 
 
20157 
  def __repr__(self):
20158 
    L = ['%s=%r' % (key, value)
20159 
      for key, value in self.__dict__.iteritems()]
20160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20161 
 
20162 
  def __eq__(self, other):
20163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20164 
 
20165 
  def __ne__(self, other):
20166 
    return not (self == other)
20167 
 
20168 
class getAllInsurers_result:
20169 
  """
20170 
  Attributes:
20171 
   - success
20172 
  """
20173 
 
20174 
  thrift_spec = (
20175 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
20176 
  )
20177 
 
20178 
  def __init__(self, success=None,):
20179 
    self.success = success
20180 
 
20181 
  def read(self, iprot):
20182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20184 
      return
20185 
    iprot.readStructBegin()
20186 
    while True:
20187 
      (fname, ftype, fid) = iprot.readFieldBegin()
20188 
      if ftype == TType.STOP:
20189 
        break
20190 
      if fid == 0:
20191 
        if ftype == TType.LIST:
20192 
          self.success = []
9155 kshitij.so 20193 
          (_etype384, _size381) = iprot.readListBegin()
20194 
          for _i385 in xrange(_size381):
20195 
            _elem386 = Insurer()
20196 
            _elem386.read(iprot)
20197 
            self.success.append(_elem386)
6838 vikram.rag 20198 
          iprot.readListEnd()
20199 
        else:
20200 
          iprot.skip(ftype)
20201 
      else:
20202 
        iprot.skip(ftype)
20203 
      iprot.readFieldEnd()
20204 
    iprot.readStructEnd()
20205 
 
20206 
  def write(self, oprot):
20207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20209 
      return
20210 
    oprot.writeStructBegin('getAllInsurers_result')
20211 
    if self.success is not None:
20212 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20213 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20214 
      for iter387 in self.success:
20215 
        iter387.write(oprot)
6838 vikram.rag 20216 
      oprot.writeListEnd()
20217 
      oprot.writeFieldEnd()
20218 
    oprot.writeFieldStop()
20219 
    oprot.writeStructEnd()
20220 
 
20221 
  def validate(self):
20222 
    return
20223 
 
20224 
 
20225 
  def __repr__(self):
20226 
    L = ['%s=%r' % (key, value)
20227 
      for key, value in self.__dict__.iteritems()]
20228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20229 
 
20230 
  def __eq__(self, other):
20231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20232 
 
20233 
  def __ne__(self, other):
20234 
    return not (self == other)
6962 rajveer 20235 
 
20236 
class updateInsuranceDeclaredAmount_args:
20237 
  """
20238 
  Attributes:
20239 
   - insurerId
20240 
   - amount
20241 
  """
20242 
 
20243 
  thrift_spec = (
20244 
    None, # 0
20245 
    (1, TType.I64, 'insurerId', None, None, ), # 1
20246 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
20247 
  )
20248 
 
20249 
  def __init__(self, insurerId=None, amount=None,):
20250 
    self.insurerId = insurerId
20251 
    self.amount = amount
20252 
 
20253 
  def read(self, iprot):
20254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20256 
      return
20257 
    iprot.readStructBegin()
20258 
    while True:
20259 
      (fname, ftype, fid) = iprot.readFieldBegin()
20260 
      if ftype == TType.STOP:
20261 
        break
20262 
      if fid == 1:
20263 
        if ftype == TType.I64:
20264 
          self.insurerId = iprot.readI64();
20265 
        else:
20266 
          iprot.skip(ftype)
20267 
      elif fid == 2:
20268 
        if ftype == TType.DOUBLE:
20269 
          self.amount = iprot.readDouble();
20270 
        else:
20271 
          iprot.skip(ftype)
20272 
      else:
20273 
        iprot.skip(ftype)
20274 
      iprot.readFieldEnd()
20275 
    iprot.readStructEnd()
20276 
 
20277 
  def write(self, oprot):
20278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20280 
      return
20281 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
20282 
    if self.insurerId is not None:
20283 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
20284 
      oprot.writeI64(self.insurerId)
20285 
      oprot.writeFieldEnd()
20286 
    if self.amount is not None:
20287 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
20288 
      oprot.writeDouble(self.amount)
20289 
      oprot.writeFieldEnd()
20290 
    oprot.writeFieldStop()
20291 
    oprot.writeStructEnd()
20292 
 
20293 
  def validate(self):
20294 
    return
20295 
 
20296 
 
20297 
  def __repr__(self):
20298 
    L = ['%s=%r' % (key, value)
20299 
      for key, value in self.__dict__.iteritems()]
20300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20301 
 
20302 
  def __eq__(self, other):
20303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20304 
 
20305 
  def __ne__(self, other):
20306 
    return not (self == other)
20307 
 
20308 
class updateInsuranceDeclaredAmount_result:
20309 
 
20310 
  thrift_spec = (
20311 
  )
20312 
 
20313 
  def read(self, iprot):
20314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20316 
      return
20317 
    iprot.readStructBegin()
20318 
    while True:
20319 
      (fname, ftype, fid) = iprot.readFieldBegin()
20320 
      if ftype == TType.STOP:
20321 
        break
20322 
      else:
20323 
        iprot.skip(ftype)
20324 
      iprot.readFieldEnd()
20325 
    iprot.readStructEnd()
20326 
 
20327 
  def write(self, oprot):
20328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20330 
      return
20331 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
20332 
    oprot.writeFieldStop()
20333 
    oprot.writeStructEnd()
20334 
 
20335 
  def validate(self):
20336 
    return
20337 
 
20338 
 
20339 
  def __repr__(self):
20340 
    L = ['%s=%r' % (key, value)
20341 
      for key, value in self.__dict__.iteritems()]
20342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20343 
 
20344 
  def __eq__(self, other):
20345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20346 
 
20347 
  def __ne__(self, other):
20348 
    return not (self == other)
7190 amar.kumar 20349 
 
20350 
class getFreebieForItem_args:
20351 
  """
20352 
  Attributes:
20353 
   - itemId
20354 
  """
20355 
 
20356 
  thrift_spec = (
20357 
    None, # 0
20358 
    (1, TType.I64, 'itemId', None, None, ), # 1
20359 
  )
20360 
 
20361 
  def __init__(self, itemId=None,):
20362 
    self.itemId = itemId
20363 
 
20364 
  def read(self, iprot):
20365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20367 
      return
20368 
    iprot.readStructBegin()
20369 
    while True:
20370 
      (fname, ftype, fid) = iprot.readFieldBegin()
20371 
      if ftype == TType.STOP:
20372 
        break
20373 
      if fid == 1:
20374 
        if ftype == TType.I64:
20375 
          self.itemId = iprot.readI64();
20376 
        else:
20377 
          iprot.skip(ftype)
20378 
      else:
20379 
        iprot.skip(ftype)
20380 
      iprot.readFieldEnd()
20381 
    iprot.readStructEnd()
20382 
 
20383 
  def write(self, oprot):
20384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20386 
      return
20387 
    oprot.writeStructBegin('getFreebieForItem_args')
20388 
    if self.itemId is not None:
20389 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20390 
      oprot.writeI64(self.itemId)
20391 
      oprot.writeFieldEnd()
20392 
    oprot.writeFieldStop()
20393 
    oprot.writeStructEnd()
20394 
 
20395 
  def validate(self):
20396 
    return
20397 
 
20398 
 
20399 
  def __repr__(self):
20400 
    L = ['%s=%r' % (key, value)
20401 
      for key, value in self.__dict__.iteritems()]
20402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20403 
 
20404 
  def __eq__(self, other):
20405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20406 
 
20407 
  def __ne__(self, other):
20408 
    return not (self == other)
20409 
 
20410 
class getFreebieForItem_result:
20411 
  """
20412 
  Attributes:
20413 
   - success
20414 
  """
20415 
 
20416 
  thrift_spec = (
20417 
    (0, TType.I64, 'success', None, None, ), # 0
20418 
  )
20419 
 
20420 
  def __init__(self, success=None,):
20421 
    self.success = success
20422 
 
20423 
  def read(self, iprot):
20424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20426 
      return
20427 
    iprot.readStructBegin()
20428 
    while True:
20429 
      (fname, ftype, fid) = iprot.readFieldBegin()
20430 
      if ftype == TType.STOP:
20431 
        break
20432 
      if fid == 0:
20433 
        if ftype == TType.I64:
20434 
          self.success = iprot.readI64();
20435 
        else:
20436 
          iprot.skip(ftype)
20437 
      else:
20438 
        iprot.skip(ftype)
20439 
      iprot.readFieldEnd()
20440 
    iprot.readStructEnd()
20441 
 
20442 
  def write(self, oprot):
20443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20445 
      return
20446 
    oprot.writeStructBegin('getFreebieForItem_result')
20447 
    if self.success is not None:
20448 
      oprot.writeFieldBegin('success', TType.I64, 0)
20449 
      oprot.writeI64(self.success)
20450 
      oprot.writeFieldEnd()
20451 
    oprot.writeFieldStop()
20452 
    oprot.writeStructEnd()
20453 
 
20454 
  def validate(self):
20455 
    return
20456 
 
20457 
 
20458 
  def __repr__(self):
20459 
    L = ['%s=%r' % (key, value)
20460 
      for key, value in self.__dict__.iteritems()]
20461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20462 
 
20463 
  def __eq__(self, other):
20464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20465 
 
20466 
  def __ne__(self, other):
20467 
    return not (self == other)
20468 
 
20469 
class addOrUpdateFreebieForItem_args:
20470 
  """
20471 
  Attributes:
20472 
   - freebieItem
20473 
  """
20474 
 
20475 
  thrift_spec = (
20476 
    None, # 0
20477 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
20478 
  )
20479 
 
20480 
  def __init__(self, freebieItem=None,):
20481 
    self.freebieItem = freebieItem
20482 
 
20483 
  def read(self, iprot):
20484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20486 
      return
20487 
    iprot.readStructBegin()
20488 
    while True:
20489 
      (fname, ftype, fid) = iprot.readFieldBegin()
20490 
      if ftype == TType.STOP:
20491 
        break
20492 
      if fid == 1:
20493 
        if ftype == TType.STRUCT:
20494 
          self.freebieItem = FreebieItem()
20495 
          self.freebieItem.read(iprot)
20496 
        else:
20497 
          iprot.skip(ftype)
20498 
      else:
20499 
        iprot.skip(ftype)
20500 
      iprot.readFieldEnd()
20501 
    iprot.readStructEnd()
20502 
 
20503 
  def write(self, oprot):
20504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20506 
      return
20507 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
20508 
    if self.freebieItem is not None:
20509 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
20510 
      self.freebieItem.write(oprot)
20511 
      oprot.writeFieldEnd()
20512 
    oprot.writeFieldStop()
20513 
    oprot.writeStructEnd()
20514 
 
20515 
  def validate(self):
20516 
    return
20517 
 
20518 
 
20519 
  def __repr__(self):
20520 
    L = ['%s=%r' % (key, value)
20521 
      for key, value in self.__dict__.iteritems()]
20522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20523 
 
20524 
  def __eq__(self, other):
20525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20526 
 
20527 
  def __ne__(self, other):
20528 
    return not (self == other)
20529 
 
20530 
class addOrUpdateFreebieForItem_result:
20531 
 
20532 
  thrift_spec = (
20533 
  )
20534 
 
20535 
  def read(self, iprot):
20536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20538 
      return
20539 
    iprot.readStructBegin()
20540 
    while True:
20541 
      (fname, ftype, fid) = iprot.readFieldBegin()
20542 
      if ftype == TType.STOP:
20543 
        break
20544 
      else:
20545 
        iprot.skip(ftype)
20546 
      iprot.readFieldEnd()
20547 
    iprot.readStructEnd()
20548 
 
20549 
  def write(self, oprot):
20550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20552 
      return
20553 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
20554 
    oprot.writeFieldStop()
20555 
    oprot.writeStructEnd()
20556 
 
20557 
  def validate(self):
20558 
    return
20559 
 
20560 
 
20561 
  def __repr__(self):
20562 
    L = ['%s=%r' % (key, value)
20563 
      for key, value in self.__dict__.iteritems()]
20564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20565 
 
20566 
  def __eq__(self, other):
20567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20568 
 
20569 
  def __ne__(self, other):
20570 
    return not (self == other)
7256 rajveer 20571 
 
7272 amit.gupta 20572 
class addOrUpdateBrandInfo_args:
20573 
  """
20574 
  Attributes:
20575 
   - brandInfo
20576 
  """
20577 
 
20578 
  thrift_spec = (
20579 
    None, # 0
20580 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
20581 
  )
20582 
 
20583 
  def __init__(self, brandInfo=None,):
20584 
    self.brandInfo = brandInfo
20585 
 
20586 
  def read(self, iprot):
20587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20589 
      return
20590 
    iprot.readStructBegin()
20591 
    while True:
20592 
      (fname, ftype, fid) = iprot.readFieldBegin()
20593 
      if ftype == TType.STOP:
20594 
        break
20595 
      if fid == 1:
20596 
        if ftype == TType.STRUCT:
20597 
          self.brandInfo = BrandInfo()
20598 
          self.brandInfo.read(iprot)
20599 
        else:
20600 
          iprot.skip(ftype)
20601 
      else:
20602 
        iprot.skip(ftype)
20603 
      iprot.readFieldEnd()
20604 
    iprot.readStructEnd()
20605 
 
20606 
  def write(self, oprot):
20607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20609 
      return
20610 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
20611 
    if self.brandInfo is not None:
20612 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
20613 
      self.brandInfo.write(oprot)
20614 
      oprot.writeFieldEnd()
20615 
    oprot.writeFieldStop()
20616 
    oprot.writeStructEnd()
20617 
 
20618 
  def validate(self):
20619 
    return
20620 
 
20621 
 
20622 
  def __repr__(self):
20623 
    L = ['%s=%r' % (key, value)
20624 
      for key, value in self.__dict__.iteritems()]
20625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20626 
 
20627 
  def __eq__(self, other):
20628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20629 
 
20630 
  def __ne__(self, other):
20631 
    return not (self == other)
20632 
 
20633 
class addOrUpdateBrandInfo_result:
20634 
 
20635 
  thrift_spec = (
20636 
  )
20637 
 
20638 
  def read(self, iprot):
20639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20641 
      return
20642 
    iprot.readStructBegin()
20643 
    while True:
20644 
      (fname, ftype, fid) = iprot.readFieldBegin()
20645 
      if ftype == TType.STOP:
20646 
        break
20647 
      else:
20648 
        iprot.skip(ftype)
20649 
      iprot.readFieldEnd()
20650 
    iprot.readStructEnd()
20651 
 
20652 
  def write(self, oprot):
20653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20655 
      return
20656 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
20657 
    oprot.writeFieldStop()
20658 
    oprot.writeStructEnd()
20659 
 
20660 
  def validate(self):
20661 
    return
20662 
 
20663 
 
20664 
  def __repr__(self):
20665 
    L = ['%s=%r' % (key, value)
20666 
      for key, value in self.__dict__.iteritems()]
20667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20668 
 
20669 
  def __eq__(self, other):
20670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20671 
 
20672 
  def __ne__(self, other):
20673 
    return not (self == other)
20674 
 
20675 
class getBrandInfo_args:
20676 
 
20677 
  thrift_spec = (
20678 
  )
20679 
 
20680 
  def read(self, iprot):
20681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20683 
      return
20684 
    iprot.readStructBegin()
20685 
    while True:
20686 
      (fname, ftype, fid) = iprot.readFieldBegin()
20687 
      if ftype == TType.STOP:
20688 
        break
20689 
      else:
20690 
        iprot.skip(ftype)
20691 
      iprot.readFieldEnd()
20692 
    iprot.readStructEnd()
20693 
 
20694 
  def write(self, oprot):
20695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20697 
      return
20698 
    oprot.writeStructBegin('getBrandInfo_args')
20699 
    oprot.writeFieldStop()
20700 
    oprot.writeStructEnd()
20701 
 
20702 
  def validate(self):
20703 
    return
20704 
 
20705 
 
20706 
  def __repr__(self):
20707 
    L = ['%s=%r' % (key, value)
20708 
      for key, value in self.__dict__.iteritems()]
20709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20710 
 
20711 
  def __eq__(self, other):
20712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20713 
 
20714 
  def __ne__(self, other):
20715 
    return not (self == other)
20716 
 
20717 
class getBrandInfo_result:
20718 
  """
20719 
  Attributes:
20720 
   - success
20721 
  """
20722 
 
20723 
  thrift_spec = (
20724 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
20725 
  )
20726 
 
20727 
  def __init__(self, success=None,):
20728 
    self.success = success
20729 
 
20730 
  def read(self, iprot):
20731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20733 
      return
20734 
    iprot.readStructBegin()
20735 
    while True:
20736 
      (fname, ftype, fid) = iprot.readFieldBegin()
20737 
      if ftype == TType.STOP:
20738 
        break
20739 
      if fid == 0:
20740 
        if ftype == TType.MAP:
20741 
          self.success = {}
9155 kshitij.so 20742 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
20743 
          for _i392 in xrange(_size388):
20744 
            _key393 = iprot.readString();
20745 
            _val394 = BrandInfo()
20746 
            _val394.read(iprot)
20747 
            self.success[_key393] = _val394
7272 amit.gupta 20748 
          iprot.readMapEnd()
20749 
        else:
20750 
          iprot.skip(ftype)
20751 
      else:
20752 
        iprot.skip(ftype)
20753 
      iprot.readFieldEnd()
20754 
    iprot.readStructEnd()
20755 
 
20756 
  def write(self, oprot):
20757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20759 
      return
20760 
    oprot.writeStructBegin('getBrandInfo_result')
20761 
    if self.success is not None:
20762 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20763 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 20764 
      for kiter395,viter396 in self.success.items():
20765 
        oprot.writeString(kiter395)
20766 
        viter396.write(oprot)
7272 amit.gupta 20767 
      oprot.writeMapEnd()
20768 
      oprot.writeFieldEnd()
20769 
    oprot.writeFieldStop()
20770 
    oprot.writeStructEnd()
20771 
 
20772 
  def validate(self):
20773 
    return
20774 
 
20775 
 
20776 
  def __repr__(self):
20777 
    L = ['%s=%r' % (key, value)
20778 
      for key, value in self.__dict__.iteritems()]
20779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20780 
 
20781 
  def __eq__(self, other):
20782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20783 
 
20784 
  def __ne__(self, other):
20785 
    return not (self == other)
20786 
 
7256 rajveer 20787 
class getStorePricing_args:
20788 
  """
20789 
  Attributes:
20790 
   - itemId
20791 
  """
20792 
 
20793 
  thrift_spec = (
20794 
    None, # 0
20795 
    (1, TType.I64, 'itemId', None, None, ), # 1
20796 
  )
20797 
 
20798 
  def __init__(self, itemId=None,):
20799 
    self.itemId = itemId
20800 
 
20801 
  def read(self, iprot):
20802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20804 
      return
20805 
    iprot.readStructBegin()
20806 
    while True:
20807 
      (fname, ftype, fid) = iprot.readFieldBegin()
20808 
      if ftype == TType.STOP:
20809 
        break
20810 
      if fid == 1:
20811 
        if ftype == TType.I64:
20812 
          self.itemId = iprot.readI64();
20813 
        else:
20814 
          iprot.skip(ftype)
20815 
      else:
20816 
        iprot.skip(ftype)
20817 
      iprot.readFieldEnd()
20818 
    iprot.readStructEnd()
20819 
 
20820 
  def write(self, oprot):
20821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20823 
      return
20824 
    oprot.writeStructBegin('getStorePricing_args')
20825 
    if self.itemId is not None:
20826 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20827 
      oprot.writeI64(self.itemId)
20828 
      oprot.writeFieldEnd()
20829 
    oprot.writeFieldStop()
20830 
    oprot.writeStructEnd()
20831 
 
20832 
  def validate(self):
20833 
    return
20834 
 
20835 
 
20836 
  def __repr__(self):
20837 
    L = ['%s=%r' % (key, value)
20838 
      for key, value in self.__dict__.iteritems()]
20839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20840 
 
20841 
  def __eq__(self, other):
20842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20843 
 
20844 
  def __ne__(self, other):
20845 
    return not (self == other)
20846 
 
20847 
class getStorePricing_result:
20848 
  """
20849 
  Attributes:
20850 
   - success
20851 
  """
20852 
 
20853 
  thrift_spec = (
20854 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
20855 
  )
20856 
 
20857 
  def __init__(self, success=None,):
20858 
    self.success = success
20859 
 
20860 
  def read(self, iprot):
20861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20863 
      return
20864 
    iprot.readStructBegin()
20865 
    while True:
20866 
      (fname, ftype, fid) = iprot.readFieldBegin()
20867 
      if ftype == TType.STOP:
20868 
        break
20869 
      if fid == 0:
20870 
        if ftype == TType.STRUCT:
20871 
          self.success = StorePricing()
20872 
          self.success.read(iprot)
20873 
        else:
20874 
          iprot.skip(ftype)
20875 
      else:
20876 
        iprot.skip(ftype)
20877 
      iprot.readFieldEnd()
20878 
    iprot.readStructEnd()
20879 
 
20880 
  def write(self, oprot):
20881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20883 
      return
20884 
    oprot.writeStructBegin('getStorePricing_result')
20885 
    if self.success is not None:
20886 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20887 
      self.success.write(oprot)
20888 
      oprot.writeFieldEnd()
20889 
    oprot.writeFieldStop()
20890 
    oprot.writeStructEnd()
20891 
 
20892 
  def validate(self):
20893 
    return
20894 
 
20895 
 
20896 
  def __repr__(self):
20897 
    L = ['%s=%r' % (key, value)
20898 
      for key, value in self.__dict__.iteritems()]
20899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20900 
 
20901 
  def __eq__(self, other):
20902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20903 
 
20904 
  def __ne__(self, other):
20905 
    return not (self == other)
7265 rajveer 20906 
 
7306 rajveer 20907 
class getStorePricings_args:
20908 
  """
20909 
  Attributes:
20910 
   - itemIds
20911 
  """
20912 
 
20913 
  thrift_spec = (
20914 
    None, # 0
20915 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20916 
  )
20917 
 
20918 
  def __init__(self, itemIds=None,):
20919 
    self.itemIds = itemIds
20920 
 
20921 
  def read(self, iprot):
20922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20924 
      return
20925 
    iprot.readStructBegin()
20926 
    while True:
20927 
      (fname, ftype, fid) = iprot.readFieldBegin()
20928 
      if ftype == TType.STOP:
20929 
        break
20930 
      if fid == 1:
20931 
        if ftype == TType.LIST:
20932 
          self.itemIds = []
9155 kshitij.so 20933 
          (_etype400, _size397) = iprot.readListBegin()
20934 
          for _i401 in xrange(_size397):
20935 
            _elem402 = iprot.readI64();
20936 
            self.itemIds.append(_elem402)
7306 rajveer 20937 
          iprot.readListEnd()
20938 
        else:
20939 
          iprot.skip(ftype)
20940 
      else:
20941 
        iprot.skip(ftype)
20942 
      iprot.readFieldEnd()
20943 
    iprot.readStructEnd()
20944 
 
20945 
  def write(self, oprot):
20946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20948 
      return
20949 
    oprot.writeStructBegin('getStorePricings_args')
20950 
    if self.itemIds is not None:
20951 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20952 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 20953 
      for iter403 in self.itemIds:
20954 
        oprot.writeI64(iter403)
7306 rajveer 20955 
      oprot.writeListEnd()
20956 
      oprot.writeFieldEnd()
20957 
    oprot.writeFieldStop()
20958 
    oprot.writeStructEnd()
20959 
 
20960 
  def validate(self):
20961 
    return
20962 
 
20963 
 
20964 
  def __repr__(self):
20965 
    L = ['%s=%r' % (key, value)
20966 
      for key, value in self.__dict__.iteritems()]
20967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20968 
 
20969 
  def __eq__(self, other):
20970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20971 
 
20972 
  def __ne__(self, other):
20973 
    return not (self == other)
20974 
 
20975 
class getStorePricings_result:
20976 
  """
20977 
  Attributes:
20978 
   - success
20979 
  """
20980 
 
20981 
  thrift_spec = (
20982 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
20983 
  )
20984 
 
20985 
  def __init__(self, success=None,):
20986 
    self.success = success
20987 
 
20988 
  def read(self, iprot):
20989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20991 
      return
20992 
    iprot.readStructBegin()
20993 
    while True:
20994 
      (fname, ftype, fid) = iprot.readFieldBegin()
20995 
      if ftype == TType.STOP:
20996 
        break
20997 
      if fid == 0:
20998 
        if ftype == TType.LIST:
20999 
          self.success = []
9155 kshitij.so 21000 
          (_etype407, _size404) = iprot.readListBegin()
21001 
          for _i408 in xrange(_size404):
21002 
            _elem409 = StorePricing()
21003 
            _elem409.read(iprot)
21004 
            self.success.append(_elem409)
7306 rajveer 21005 
          iprot.readListEnd()
21006 
        else:
21007 
          iprot.skip(ftype)
21008 
      else:
21009 
        iprot.skip(ftype)
21010 
      iprot.readFieldEnd()
21011 
    iprot.readStructEnd()
21012 
 
21013 
  def write(self, oprot):
21014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21016 
      return
21017 
    oprot.writeStructBegin('getStorePricings_result')
21018 
    if self.success is not None:
21019 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21020 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21021 
      for iter410 in self.success:
21022 
        iter410.write(oprot)
7306 rajveer 21023 
      oprot.writeListEnd()
21024 
      oprot.writeFieldEnd()
21025 
    oprot.writeFieldStop()
21026 
    oprot.writeStructEnd()
21027 
 
21028 
  def validate(self):
21029 
    return
21030 
 
21031 
 
21032 
  def __repr__(self):
21033 
    L = ['%s=%r' % (key, value)
21034 
      for key, value in self.__dict__.iteritems()]
21035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21036 
 
21037 
  def __eq__(self, other):
21038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21039 
 
21040 
  def __ne__(self, other):
21041 
    return not (self == other)
21042 
 
7265 rajveer 21043 
class updateStorePricing_args:
21044 
  """
21045 
  Attributes:
21046 
   - sp
7382 rajveer 21047 
   - allColors
7265 rajveer 21048 
  """
21049 
 
21050 
  thrift_spec = (
21051 
    None, # 0
21052 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 21053 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 21054 
  )
21055 
 
7382 rajveer 21056 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 21057 
    self.sp = sp
7382 rajveer 21058 
    self.allColors = allColors
7265 rajveer 21059 
 
21060 
  def read(self, iprot):
21061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21063 
      return
21064 
    iprot.readStructBegin()
21065 
    while True:
21066 
      (fname, ftype, fid) = iprot.readFieldBegin()
21067 
      if ftype == TType.STOP:
21068 
        break
21069 
      if fid == 1:
21070 
        if ftype == TType.STRUCT:
21071 
          self.sp = StorePricing()
21072 
          self.sp.read(iprot)
21073 
        else:
21074 
          iprot.skip(ftype)
7382 rajveer 21075 
      elif fid == 2:
21076 
        if ftype == TType.BOOL:
21077 
          self.allColors = iprot.readBool();
21078 
        else:
21079 
          iprot.skip(ftype)
7265 rajveer 21080 
      else:
21081 
        iprot.skip(ftype)
21082 
      iprot.readFieldEnd()
21083 
    iprot.readStructEnd()
21084 
 
21085 
  def write(self, oprot):
21086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21088 
      return
21089 
    oprot.writeStructBegin('updateStorePricing_args')
21090 
    if self.sp is not None:
21091 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
21092 
      self.sp.write(oprot)
21093 
      oprot.writeFieldEnd()
7382 rajveer 21094 
    if self.allColors is not None:
21095 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
21096 
      oprot.writeBool(self.allColors)
21097 
      oprot.writeFieldEnd()
7265 rajveer 21098 
    oprot.writeFieldStop()
21099 
    oprot.writeStructEnd()
21100 
 
21101 
  def validate(self):
21102 
    return
21103 
 
21104 
 
21105 
  def __repr__(self):
21106 
    L = ['%s=%r' % (key, value)
21107 
      for key, value in self.__dict__.iteritems()]
21108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21109 
 
21110 
  def __eq__(self, other):
21111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21112 
 
21113 
  def __ne__(self, other):
21114 
    return not (self == other)
21115 
 
21116 
class updateStorePricing_result:
21117 
 
21118 
  thrift_spec = (
21119 
  )
21120 
 
21121 
  def read(self, iprot):
21122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21124 
      return
21125 
    iprot.readStructBegin()
21126 
    while True:
21127 
      (fname, ftype, fid) = iprot.readFieldBegin()
21128 
      if ftype == TType.STOP:
21129 
        break
21130 
      else:
21131 
        iprot.skip(ftype)
21132 
      iprot.readFieldEnd()
21133 
    iprot.readStructEnd()
21134 
 
21135 
  def write(self, oprot):
21136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21138 
      return
21139 
    oprot.writeStructBegin('updateStorePricing_result')
21140 
    oprot.writeFieldStop()
21141 
    oprot.writeStructEnd()
21142 
 
21143 
  def validate(self):
21144 
    return
21145 
 
21146 
 
21147 
  def __repr__(self):
21148 
    L = ['%s=%r' % (key, value)
21149 
      for key, value in self.__dict__.iteritems()]
21150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21151 
 
21152 
  def __eq__(self, other):
21153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21154 
 
21155 
  def __ne__(self, other):
21156 
    return not (self == other)
7281 kshitij.so 21157 
 
21158 
class getAllAmazonListedItems_args:
21159 
 
21160 
  thrift_spec = (
21161 
  )
21162 
 
21163 
  def read(self, iprot):
21164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21166 
      return
21167 
    iprot.readStructBegin()
21168 
    while True:
21169 
      (fname, ftype, fid) = iprot.readFieldBegin()
21170 
      if ftype == TType.STOP:
21171 
        break
21172 
      else:
21173 
        iprot.skip(ftype)
21174 
      iprot.readFieldEnd()
21175 
    iprot.readStructEnd()
21176 
 
21177 
  def write(self, oprot):
21178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21180 
      return
21181 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
21182 
    oprot.writeFieldStop()
21183 
    oprot.writeStructEnd()
21184 
 
21185 
  def validate(self):
21186 
    return
21187 
 
21188 
 
21189 
  def __repr__(self):
21190 
    L = ['%s=%r' % (key, value)
21191 
      for key, value in self.__dict__.iteritems()]
21192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21193 
 
21194 
  def __eq__(self, other):
21195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21196 
 
21197 
  def __ne__(self, other):
21198 
    return not (self == other)
21199 
 
21200 
class getAllAmazonListedItems_result:
21201 
  """
21202 
  Attributes:
21203 
   - success
21204 
  """
21205 
 
21206 
  thrift_spec = (
21207 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21208 
  )
21209 
 
21210 
  def __init__(self, success=None,):
21211 
    self.success = success
21212 
 
21213 
  def read(self, iprot):
21214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21216 
      return
21217 
    iprot.readStructBegin()
21218 
    while True:
21219 
      (fname, ftype, fid) = iprot.readFieldBegin()
21220 
      if ftype == TType.STOP:
21221 
        break
21222 
      if fid == 0:
21223 
        if ftype == TType.LIST:
21224 
          self.success = []
9155 kshitij.so 21225 
          (_etype414, _size411) = iprot.readListBegin()
21226 
          for _i415 in xrange(_size411):
21227 
            _elem416 = Amazonlisted()
21228 
            _elem416.read(iprot)
21229 
            self.success.append(_elem416)
7281 kshitij.so 21230 
          iprot.readListEnd()
21231 
        else:
21232 
          iprot.skip(ftype)
21233 
      else:
21234 
        iprot.skip(ftype)
21235 
      iprot.readFieldEnd()
21236 
    iprot.readStructEnd()
21237 
 
21238 
  def write(self, oprot):
21239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21241 
      return
21242 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
21243 
    if self.success is not None:
21244 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21245 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21246 
      for iter417 in self.success:
21247 
        iter417.write(oprot)
7281 kshitij.so 21248 
      oprot.writeListEnd()
21249 
      oprot.writeFieldEnd()
21250 
    oprot.writeFieldStop()
21251 
    oprot.writeStructEnd()
21252 
 
21253 
  def validate(self):
21254 
    return
21255 
 
21256 
 
21257 
  def __repr__(self):
21258 
    L = ['%s=%r' % (key, value)
21259 
      for key, value in self.__dict__.iteritems()]
21260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21261 
 
21262 
  def __eq__(self, other):
21263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21264 
 
21265 
  def __ne__(self, other):
21266 
    return not (self == other)
21267 
 
8619 kshitij.so 21268 
class searchAmazonItems_args:
21269 
  """
21270 
  Attributes:
21271 
   - searchTerm
21272 
   - offset
21273 
   - limit
21274 
  """
21275 
 
21276 
  thrift_spec = (
21277 
    None, # 0
21278 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
21279 
    (2, TType.I64, 'offset', None, None, ), # 2
21280 
    (3, TType.I64, 'limit', None, None, ), # 3
21281 
  )
21282 
 
21283 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
21284 
    self.searchTerm = searchTerm
21285 
    self.offset = offset
21286 
    self.limit = limit
21287 
 
21288 
  def read(self, iprot):
21289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21291 
      return
21292 
    iprot.readStructBegin()
21293 
    while True:
21294 
      (fname, ftype, fid) = iprot.readFieldBegin()
21295 
      if ftype == TType.STOP:
21296 
        break
21297 
      if fid == 1:
21298 
        if ftype == TType.LIST:
21299 
          self.searchTerm = []
9155 kshitij.so 21300 
          (_etype421, _size418) = iprot.readListBegin()
21301 
          for _i422 in xrange(_size418):
21302 
            _elem423 = iprot.readString();
21303 
            self.searchTerm.append(_elem423)
8619 kshitij.so 21304 
          iprot.readListEnd()
21305 
        else:
21306 
          iprot.skip(ftype)
21307 
      elif fid == 2:
21308 
        if ftype == TType.I64:
21309 
          self.offset = iprot.readI64();
21310 
        else:
21311 
          iprot.skip(ftype)
21312 
      elif fid == 3:
21313 
        if ftype == TType.I64:
21314 
          self.limit = iprot.readI64();
21315 
        else:
21316 
          iprot.skip(ftype)
21317 
      else:
21318 
        iprot.skip(ftype)
21319 
      iprot.readFieldEnd()
21320 
    iprot.readStructEnd()
21321 
 
21322 
  def write(self, oprot):
21323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21325 
      return
21326 
    oprot.writeStructBegin('searchAmazonItems_args')
21327 
    if self.searchTerm is not None:
21328 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
21329 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 21330 
      for iter424 in self.searchTerm:
21331 
        oprot.writeString(iter424)
8619 kshitij.so 21332 
      oprot.writeListEnd()
21333 
      oprot.writeFieldEnd()
21334 
    if self.offset is not None:
21335 
      oprot.writeFieldBegin('offset', TType.I64, 2)
21336 
      oprot.writeI64(self.offset)
21337 
      oprot.writeFieldEnd()
21338 
    if self.limit is not None:
21339 
      oprot.writeFieldBegin('limit', TType.I64, 3)
21340 
      oprot.writeI64(self.limit)
21341 
      oprot.writeFieldEnd()
21342 
    oprot.writeFieldStop()
21343 
    oprot.writeStructEnd()
21344 
 
21345 
  def validate(self):
21346 
    return
21347 
 
21348 
 
21349 
  def __repr__(self):
21350 
    L = ['%s=%r' % (key, value)
21351 
      for key, value in self.__dict__.iteritems()]
21352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21353 
 
21354 
  def __eq__(self, other):
21355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21356 
 
21357 
  def __ne__(self, other):
21358 
    return not (self == other)
21359 
 
21360 
class searchAmazonItems_result:
21361 
  """
21362 
  Attributes:
21363 
   - success
21364 
  """
21365 
 
21366 
  thrift_spec = (
21367 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21368 
  )
21369 
 
21370 
  def __init__(self, success=None,):
21371 
    self.success = success
21372 
 
21373 
  def read(self, iprot):
21374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21376 
      return
21377 
    iprot.readStructBegin()
21378 
    while True:
21379 
      (fname, ftype, fid) = iprot.readFieldBegin()
21380 
      if ftype == TType.STOP:
21381 
        break
21382 
      if fid == 0:
21383 
        if ftype == TType.LIST:
21384 
          self.success = []
9155 kshitij.so 21385 
          (_etype428, _size425) = iprot.readListBegin()
21386 
          for _i429 in xrange(_size425):
21387 
            _elem430 = Amazonlisted()
21388 
            _elem430.read(iprot)
21389 
            self.success.append(_elem430)
8619 kshitij.so 21390 
          iprot.readListEnd()
21391 
        else:
21392 
          iprot.skip(ftype)
21393 
      else:
21394 
        iprot.skip(ftype)
21395 
      iprot.readFieldEnd()
21396 
    iprot.readStructEnd()
21397 
 
21398 
  def write(self, oprot):
21399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21401 
      return
21402 
    oprot.writeStructBegin('searchAmazonItems_result')
21403 
    if self.success is not None:
21404 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21405 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21406 
      for iter431 in self.success:
21407 
        iter431.write(oprot)
8619 kshitij.so 21408 
      oprot.writeListEnd()
21409 
      oprot.writeFieldEnd()
21410 
    oprot.writeFieldStop()
21411 
    oprot.writeStructEnd()
21412 
 
21413 
  def validate(self):
21414 
    return
21415 
 
21416 
 
21417 
  def __repr__(self):
21418 
    L = ['%s=%r' % (key, value)
21419 
      for key, value in self.__dict__.iteritems()]
21420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21421 
 
21422 
  def __eq__(self, other):
21423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21424 
 
21425 
  def __ne__(self, other):
21426 
    return not (self == other)
21427 
 
21428 
class getAmazonSearchResultCount_args:
21429 
  """
21430 
  Attributes:
21431 
   - searchTerm
21432 
  """
21433 
 
21434 
  thrift_spec = (
21435 
    None, # 0
21436 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
21437 
  )
21438 
 
21439 
  def __init__(self, searchTerm=None,):
21440 
    self.searchTerm = searchTerm
21441 
 
21442 
  def read(self, iprot):
21443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21445 
      return
21446 
    iprot.readStructBegin()
21447 
    while True:
21448 
      (fname, ftype, fid) = iprot.readFieldBegin()
21449 
      if ftype == TType.STOP:
21450 
        break
21451 
      if fid == 1:
21452 
        if ftype == TType.LIST:
21453 
          self.searchTerm = []
9155 kshitij.so 21454 
          (_etype435, _size432) = iprot.readListBegin()
21455 
          for _i436 in xrange(_size432):
21456 
            _elem437 = iprot.readString();
21457 
            self.searchTerm.append(_elem437)
8619 kshitij.so 21458 
          iprot.readListEnd()
21459 
        else:
21460 
          iprot.skip(ftype)
21461 
      else:
21462 
        iprot.skip(ftype)
21463 
      iprot.readFieldEnd()
21464 
    iprot.readStructEnd()
21465 
 
21466 
  def write(self, oprot):
21467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21469 
      return
21470 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
21471 
    if self.searchTerm is not None:
21472 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
21473 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 21474 
      for iter438 in self.searchTerm:
21475 
        oprot.writeString(iter438)
8619 kshitij.so 21476 
      oprot.writeListEnd()
21477 
      oprot.writeFieldEnd()
21478 
    oprot.writeFieldStop()
21479 
    oprot.writeStructEnd()
21480 
 
21481 
  def validate(self):
21482 
    return
21483 
 
21484 
 
21485 
  def __repr__(self):
21486 
    L = ['%s=%r' % (key, value)
21487 
      for key, value in self.__dict__.iteritems()]
21488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21489 
 
21490 
  def __eq__(self, other):
21491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21492 
 
21493 
  def __ne__(self, other):
21494 
    return not (self == other)
21495 
 
21496 
class getAmazonSearchResultCount_result:
21497 
  """
21498 
  Attributes:
21499 
   - success
21500 
  """
21501 
 
21502 
  thrift_spec = (
21503 
    (0, TType.I64, 'success', None, None, ), # 0
21504 
  )
21505 
 
21506 
  def __init__(self, success=None,):
21507 
    self.success = success
21508 
 
21509 
  def read(self, iprot):
21510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21512 
      return
21513 
    iprot.readStructBegin()
21514 
    while True:
21515 
      (fname, ftype, fid) = iprot.readFieldBegin()
21516 
      if ftype == TType.STOP:
21517 
        break
21518 
      if fid == 0:
21519 
        if ftype == TType.I64:
21520 
          self.success = iprot.readI64();
21521 
        else:
21522 
          iprot.skip(ftype)
21523 
      else:
21524 
        iprot.skip(ftype)
21525 
      iprot.readFieldEnd()
21526 
    iprot.readStructEnd()
21527 
 
21528 
  def write(self, oprot):
21529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21531 
      return
21532 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
21533 
    if self.success is not None:
21534 
      oprot.writeFieldBegin('success', TType.I64, 0)
21535 
      oprot.writeI64(self.success)
21536 
      oprot.writeFieldEnd()
21537 
    oprot.writeFieldStop()
21538 
    oprot.writeStructEnd()
21539 
 
21540 
  def validate(self):
21541 
    return
21542 
 
21543 
 
21544 
  def __repr__(self):
21545 
    L = ['%s=%r' % (key, value)
21546 
      for key, value in self.__dict__.iteritems()]
21547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21548 
 
21549 
  def __eq__(self, other):
21550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21551 
 
21552 
  def __ne__(self, other):
21553 
    return not (self == other)
21554 
 
21555 
class getCountForAmazonlistedItems_args:
21556 
 
21557 
  thrift_spec = (
21558 
  )
21559 
 
21560 
  def read(self, iprot):
21561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21563 
      return
21564 
    iprot.readStructBegin()
21565 
    while True:
21566 
      (fname, ftype, fid) = iprot.readFieldBegin()
21567 
      if ftype == TType.STOP:
21568 
        break
21569 
      else:
21570 
        iprot.skip(ftype)
21571 
      iprot.readFieldEnd()
21572 
    iprot.readStructEnd()
21573 
 
21574 
  def write(self, oprot):
21575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21577 
      return
21578 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
21579 
    oprot.writeFieldStop()
21580 
    oprot.writeStructEnd()
21581 
 
21582 
  def validate(self):
21583 
    return
21584 
 
21585 
 
21586 
  def __repr__(self):
21587 
    L = ['%s=%r' % (key, value)
21588 
      for key, value in self.__dict__.iteritems()]
21589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21590 
 
21591 
  def __eq__(self, other):
21592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21593 
 
21594 
  def __ne__(self, other):
21595 
    return not (self == other)
21596 
 
21597 
class getCountForAmazonlistedItems_result:
21598 
  """
21599 
  Attributes:
21600 
   - success
21601 
  """
21602 
 
21603 
  thrift_spec = (
21604 
    (0, TType.I64, 'success', None, None, ), # 0
21605 
  )
21606 
 
21607 
  def __init__(self, success=None,):
21608 
    self.success = success
21609 
 
21610 
  def read(self, iprot):
21611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21613 
      return
21614 
    iprot.readStructBegin()
21615 
    while True:
21616 
      (fname, ftype, fid) = iprot.readFieldBegin()
21617 
      if ftype == TType.STOP:
21618 
        break
21619 
      if fid == 0:
21620 
        if ftype == TType.I64:
21621 
          self.success = iprot.readI64();
21622 
        else:
21623 
          iprot.skip(ftype)
21624 
      else:
21625 
        iprot.skip(ftype)
21626 
      iprot.readFieldEnd()
21627 
    iprot.readStructEnd()
21628 
 
21629 
  def write(self, oprot):
21630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21632 
      return
21633 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
21634 
    if self.success is not None:
21635 
      oprot.writeFieldBegin('success', TType.I64, 0)
21636 
      oprot.writeI64(self.success)
21637 
      oprot.writeFieldEnd()
21638 
    oprot.writeFieldStop()
21639 
    oprot.writeStructEnd()
21640 
 
21641 
  def validate(self):
21642 
    return
21643 
 
21644 
 
21645 
  def __repr__(self):
21646 
    L = ['%s=%r' % (key, value)
21647 
      for key, value in self.__dict__.iteritems()]
21648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21649 
 
21650 
  def __eq__(self, other):
21651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21652 
 
21653 
  def __ne__(self, other):
21654 
    return not (self == other)
21655 
 
7281 kshitij.so 21656 
class getAmazonItemDetails_args:
21657 
  """
21658 
  Attributes:
21659 
   - itemId
21660 
  """
21661 
 
21662 
  thrift_spec = (
21663 
    None, # 0
21664 
    (1, TType.I64, 'itemId', None, None, ), # 1
21665 
  )
21666 
 
21667 
  def __init__(self, itemId=None,):
21668 
    self.itemId = itemId
21669 
 
21670 
  def read(self, iprot):
21671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21673 
      return
21674 
    iprot.readStructBegin()
21675 
    while True:
21676 
      (fname, ftype, fid) = iprot.readFieldBegin()
21677 
      if ftype == TType.STOP:
21678 
        break
21679 
      if fid == 1:
21680 
        if ftype == TType.I64:
21681 
          self.itemId = iprot.readI64();
21682 
        else:
21683 
          iprot.skip(ftype)
21684 
      else:
21685 
        iprot.skip(ftype)
21686 
      iprot.readFieldEnd()
21687 
    iprot.readStructEnd()
21688 
 
21689 
  def write(self, oprot):
21690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21692 
      return
21693 
    oprot.writeStructBegin('getAmazonItemDetails_args')
21694 
    if self.itemId is not None:
21695 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21696 
      oprot.writeI64(self.itemId)
21697 
      oprot.writeFieldEnd()
21698 
    oprot.writeFieldStop()
21699 
    oprot.writeStructEnd()
21700 
 
21701 
  def validate(self):
21702 
    return
21703 
 
21704 
 
21705 
  def __repr__(self):
21706 
    L = ['%s=%r' % (key, value)
21707 
      for key, value in self.__dict__.iteritems()]
21708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21709 
 
21710 
  def __eq__(self, other):
21711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21712 
 
21713 
  def __ne__(self, other):
21714 
    return not (self == other)
21715 
 
21716 
class getAmazonItemDetails_result:
21717 
  """
21718 
  Attributes:
21719 
   - success
21720 
  """
21721 
 
21722 
  thrift_spec = (
21723 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
21724 
  )
21725 
 
21726 
  def __init__(self, success=None,):
21727 
    self.success = success
21728 
 
21729 
  def read(self, iprot):
21730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21732 
      return
21733 
    iprot.readStructBegin()
21734 
    while True:
21735 
      (fname, ftype, fid) = iprot.readFieldBegin()
21736 
      if ftype == TType.STOP:
21737 
        break
21738 
      if fid == 0:
21739 
        if ftype == TType.STRUCT:
21740 
          self.success = Amazonlisted()
21741 
          self.success.read(iprot)
21742 
        else:
21743 
          iprot.skip(ftype)
21744 
      else:
21745 
        iprot.skip(ftype)
21746 
      iprot.readFieldEnd()
21747 
    iprot.readStructEnd()
21748 
 
21749 
  def write(self, oprot):
21750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21752 
      return
21753 
    oprot.writeStructBegin('getAmazonItemDetails_result')
21754 
    if self.success is not None:
21755 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21756 
      self.success.write(oprot)
21757 
      oprot.writeFieldEnd()
21758 
    oprot.writeFieldStop()
21759 
    oprot.writeStructEnd()
21760 
 
21761 
  def validate(self):
21762 
    return
21763 
 
21764 
 
21765 
  def __repr__(self):
21766 
    L = ['%s=%r' % (key, value)
21767 
      for key, value in self.__dict__.iteritems()]
21768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21769 
 
21770 
  def __eq__(self, other):
21771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21772 
 
21773 
  def __ne__(self, other):
21774 
    return not (self == other)
21775 
 
21776 
class updateAmazonItemDetails_args:
21777 
  """
21778 
  Attributes:
8168 kshitij.so 21779 
   - amazonlisted
7281 kshitij.so 21780 
  """
21781 
 
21782 
  thrift_spec = (
21783 
    None, # 0
8168 kshitij.so 21784 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 21785 
  )
21786 
 
8168 kshitij.so 21787 
  def __init__(self, amazonlisted=None,):
21788 
    self.amazonlisted = amazonlisted
7281 kshitij.so 21789 
 
21790 
  def read(self, iprot):
21791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21793 
      return
21794 
    iprot.readStructBegin()
21795 
    while True:
21796 
      (fname, ftype, fid) = iprot.readFieldBegin()
21797 
      if ftype == TType.STOP:
21798 
        break
21799 
      if fid == 1:
8168 kshitij.so 21800 
        if ftype == TType.STRUCT:
21801 
          self.amazonlisted = Amazonlisted()
21802 
          self.amazonlisted.read(iprot)
7281 kshitij.so 21803 
        else:
21804 
          iprot.skip(ftype)
21805 
      else:
21806 
        iprot.skip(ftype)
21807 
      iprot.readFieldEnd()
21808 
    iprot.readStructEnd()
21809 
 
21810 
  def write(self, oprot):
21811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21813 
      return
21814 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 21815 
    if self.amazonlisted is not None:
21816 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
21817 
      self.amazonlisted.write(oprot)
7281 kshitij.so 21818 
      oprot.writeFieldEnd()
21819 
    oprot.writeFieldStop()
21820 
    oprot.writeStructEnd()
21821 
 
21822 
  def validate(self):
21823 
    return
21824 
 
21825 
 
21826 
  def __repr__(self):
21827 
    L = ['%s=%r' % (key, value)
21828 
      for key, value in self.__dict__.iteritems()]
21829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21830 
 
21831 
  def __eq__(self, other):
21832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21833 
 
21834 
  def __ne__(self, other):
21835 
    return not (self == other)
21836 
 
21837 
class updateAmazonItemDetails_result:
21838 
 
21839 
  thrift_spec = (
21840 
  )
21841 
 
21842 
  def read(self, iprot):
21843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21845 
      return
21846 
    iprot.readStructBegin()
21847 
    while True:
21848 
      (fname, ftype, fid) = iprot.readFieldBegin()
21849 
      if ftype == TType.STOP:
21850 
        break
21851 
      else:
21852 
        iprot.skip(ftype)
21853 
      iprot.readFieldEnd()
21854 
    iprot.readStructEnd()
21855 
 
21856 
  def write(self, oprot):
21857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21859 
      return
21860 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
21861 
    oprot.writeFieldStop()
21862 
    oprot.writeStructEnd()
21863 
 
21864 
  def validate(self):
21865 
    return
21866 
 
21867 
 
21868 
  def __repr__(self):
21869 
    L = ['%s=%r' % (key, value)
21870 
      for key, value in self.__dict__.iteritems()]
21871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21872 
 
21873 
  def __eq__(self, other):
21874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21875 
 
21876 
  def __ne__(self, other):
21877 
    return not (self == other)
21878 
 
21879 
class addAmazonItem_args:
21880 
  """
21881 
  Attributes:
21882 
   - amazonlisted
21883 
  """
21884 
 
21885 
  thrift_spec = (
21886 
    None, # 0
21887 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
21888 
  )
21889 
 
21890 
  def __init__(self, amazonlisted=None,):
21891 
    self.amazonlisted = amazonlisted
21892 
 
21893 
  def read(self, iprot):
21894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21896 
      return
21897 
    iprot.readStructBegin()
21898 
    while True:
21899 
      (fname, ftype, fid) = iprot.readFieldBegin()
21900 
      if ftype == TType.STOP:
21901 
        break
21902 
      if fid == 1:
21903 
        if ftype == TType.STRUCT:
21904 
          self.amazonlisted = Amazonlisted()
21905 
          self.amazonlisted.read(iprot)
21906 
        else:
21907 
          iprot.skip(ftype)
21908 
      else:
21909 
        iprot.skip(ftype)
21910 
      iprot.readFieldEnd()
21911 
    iprot.readStructEnd()
21912 
 
21913 
  def write(self, oprot):
21914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21916 
      return
21917 
    oprot.writeStructBegin('addAmazonItem_args')
21918 
    if self.amazonlisted is not None:
21919 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
21920 
      self.amazonlisted.write(oprot)
21921 
      oprot.writeFieldEnd()
21922 
    oprot.writeFieldStop()
21923 
    oprot.writeStructEnd()
21924 
 
21925 
  def validate(self):
21926 
    return
21927 
 
21928 
 
21929 
  def __repr__(self):
21930 
    L = ['%s=%r' % (key, value)
21931 
      for key, value in self.__dict__.iteritems()]
21932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21933 
 
21934 
  def __eq__(self, other):
21935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21936 
 
21937 
  def __ne__(self, other):
21938 
    return not (self == other)
21939 
 
21940 
class addAmazonItem_result:
21941 
 
21942 
  thrift_spec = (
21943 
  )
21944 
 
21945 
  def read(self, iprot):
21946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21948 
      return
21949 
    iprot.readStructBegin()
21950 
    while True:
21951 
      (fname, ftype, fid) = iprot.readFieldBegin()
21952 
      if ftype == TType.STOP:
21953 
        break
21954 
      else:
21955 
        iprot.skip(ftype)
21956 
      iprot.readFieldEnd()
21957 
    iprot.readStructEnd()
21958 
 
21959 
  def write(self, oprot):
21960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21962 
      return
21963 
    oprot.writeStructBegin('addAmazonItem_result')
21964 
    oprot.writeFieldStop()
21965 
    oprot.writeStructEnd()
21966 
 
21967 
  def validate(self):
21968 
    return
21969 
 
21970 
 
21971 
  def __repr__(self):
21972 
    L = ['%s=%r' % (key, value)
21973 
      for key, value in self.__dict__.iteritems()]
21974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21975 
 
21976 
  def __eq__(self, other):
21977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21978 
 
21979 
  def __ne__(self, other):
21980 
    return not (self == other)
7291 vikram.rag 21981 
 
21982 
class getAsinItems_args:
21983 
 
21984 
  thrift_spec = (
21985 
  )
21986 
 
21987 
  def read(self, iprot):
21988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21990 
      return
21991 
    iprot.readStructBegin()
21992 
    while True:
21993 
      (fname, ftype, fid) = iprot.readFieldBegin()
21994 
      if ftype == TType.STOP:
21995 
        break
21996 
      else:
21997 
        iprot.skip(ftype)
21998 
      iprot.readFieldEnd()
21999 
    iprot.readStructEnd()
22000 
 
22001 
  def write(self, oprot):
22002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22004 
      return
22005 
    oprot.writeStructBegin('getAsinItems_args')
22006 
    oprot.writeFieldStop()
22007 
    oprot.writeStructEnd()
22008 
 
22009 
  def validate(self):
22010 
    return
22011 
 
22012 
 
22013 
  def __repr__(self):
22014 
    L = ['%s=%r' % (key, value)
22015 
      for key, value in self.__dict__.iteritems()]
22016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22017 
 
22018 
  def __eq__(self, other):
22019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22020 
 
22021 
  def __ne__(self, other):
22022 
    return not (self == other)
22023 
 
22024 
class getAsinItems_result:
22025 
  """
22026 
  Attributes:
22027 
   - success
22028 
  """
22029 
 
22030 
  thrift_spec = (
22031 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
22032 
  )
22033 
 
22034 
  def __init__(self, success=None,):
22035 
    self.success = success
22036 
 
22037 
  def read(self, iprot):
22038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22040 
      return
22041 
    iprot.readStructBegin()
22042 
    while True:
22043 
      (fname, ftype, fid) = iprot.readFieldBegin()
22044 
      if ftype == TType.STOP:
22045 
        break
22046 
      if fid == 0:
22047 
        if ftype == TType.LIST:
22048 
          self.success = []
9155 kshitij.so 22049 
          (_etype442, _size439) = iprot.readListBegin()
22050 
          for _i443 in xrange(_size439):
22051 
            _elem444 = Item()
22052 
            _elem444.read(iprot)
22053 
            self.success.append(_elem444)
7291 vikram.rag 22054 
          iprot.readListEnd()
22055 
        else:
22056 
          iprot.skip(ftype)
22057 
      else:
22058 
        iprot.skip(ftype)
22059 
      iprot.readFieldEnd()
22060 
    iprot.readStructEnd()
22061 
 
22062 
  def write(self, oprot):
22063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22065 
      return
22066 
    oprot.writeStructBegin('getAsinItems_result')
22067 
    if self.success is not None:
22068 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22069 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22070 
      for iter445 in self.success:
22071 
        iter445.write(oprot)
7291 vikram.rag 22072 
      oprot.writeListEnd()
22073 
      oprot.writeFieldEnd()
22074 
    oprot.writeFieldStop()
22075 
    oprot.writeStructEnd()
22076 
 
22077 
  def validate(self):
22078 
    return
22079 
 
22080 
 
22081 
  def __repr__(self):
22082 
    L = ['%s=%r' % (key, value)
22083 
      for key, value in self.__dict__.iteritems()]
22084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22085 
 
22086 
  def __eq__(self, other):
22087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22088 
 
22089 
  def __ne__(self, other):
22090 
    return not (self == other)
22091 
 
22092 
class getAllFbaListedItems_args:
22093 
 
22094 
  thrift_spec = (
22095 
  )
22096 
 
22097 
  def read(self, iprot):
22098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22100 
      return
22101 
    iprot.readStructBegin()
22102 
    while True:
22103 
      (fname, ftype, fid) = iprot.readFieldBegin()
22104 
      if ftype == TType.STOP:
22105 
        break
22106 
      else:
22107 
        iprot.skip(ftype)
22108 
      iprot.readFieldEnd()
22109 
    iprot.readStructEnd()
22110 
 
22111 
  def write(self, oprot):
22112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22114 
      return
22115 
    oprot.writeStructBegin('getAllFbaListedItems_args')
22116 
    oprot.writeFieldStop()
22117 
    oprot.writeStructEnd()
22118 
 
22119 
  def validate(self):
22120 
    return
22121 
 
22122 
 
22123 
  def __repr__(self):
22124 
    L = ['%s=%r' % (key, value)
22125 
      for key, value in self.__dict__.iteritems()]
22126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22127 
 
22128 
  def __eq__(self, other):
22129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22130 
 
22131 
  def __ne__(self, other):
22132 
    return not (self == other)
22133 
 
22134 
class getAllFbaListedItems_result:
22135 
  """
22136 
  Attributes:
22137 
   - success
22138 
  """
22139 
 
22140 
  thrift_spec = (
22141 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22142 
  )
22143 
 
22144 
  def __init__(self, success=None,):
22145 
    self.success = success
22146 
 
22147 
  def read(self, iprot):
22148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22150 
      return
22151 
    iprot.readStructBegin()
22152 
    while True:
22153 
      (fname, ftype, fid) = iprot.readFieldBegin()
22154 
      if ftype == TType.STOP:
22155 
        break
22156 
      if fid == 0:
22157 
        if ftype == TType.LIST:
22158 
          self.success = []
9155 kshitij.so 22159 
          (_etype449, _size446) = iprot.readListBegin()
22160 
          for _i450 in xrange(_size446):
22161 
            _elem451 = Amazonlisted()
22162 
            _elem451.read(iprot)
22163 
            self.success.append(_elem451)
7291 vikram.rag 22164 
          iprot.readListEnd()
22165 
        else:
22166 
          iprot.skip(ftype)
22167 
      else:
22168 
        iprot.skip(ftype)
22169 
      iprot.readFieldEnd()
22170 
    iprot.readStructEnd()
22171 
 
22172 
  def write(self, oprot):
22173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22175 
      return
22176 
    oprot.writeStructBegin('getAllFbaListedItems_result')
22177 
    if self.success is not None:
22178 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22179 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22180 
      for iter452 in self.success:
22181 
        iter452.write(oprot)
7291 vikram.rag 22182 
      oprot.writeListEnd()
22183 
      oprot.writeFieldEnd()
22184 
    oprot.writeFieldStop()
22185 
    oprot.writeStructEnd()
22186 
 
22187 
  def validate(self):
22188 
    return
22189 
 
22190 
 
22191 
  def __repr__(self):
22192 
    L = ['%s=%r' % (key, value)
22193 
      for key, value in self.__dict__.iteritems()]
22194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22195 
 
22196 
  def __eq__(self, other):
22197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22198 
 
22199 
  def __ne__(self, other):
22200 
    return not (self == other)
22201 
 
22202 
class getAllNonFbaListedItems_args:
22203 
 
22204 
  thrift_spec = (
22205 
  )
22206 
 
22207 
  def read(self, iprot):
22208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22210 
      return
22211 
    iprot.readStructBegin()
22212 
    while True:
22213 
      (fname, ftype, fid) = iprot.readFieldBegin()
22214 
      if ftype == TType.STOP:
22215 
        break
22216 
      else:
22217 
        iprot.skip(ftype)
22218 
      iprot.readFieldEnd()
22219 
    iprot.readStructEnd()
22220 
 
22221 
  def write(self, oprot):
22222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22224 
      return
22225 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
22226 
    oprot.writeFieldStop()
22227 
    oprot.writeStructEnd()
22228 
 
22229 
  def validate(self):
22230 
    return
22231 
 
22232 
 
22233 
  def __repr__(self):
22234 
    L = ['%s=%r' % (key, value)
22235 
      for key, value in self.__dict__.iteritems()]
22236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22237 
 
22238 
  def __eq__(self, other):
22239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22240 
 
22241 
  def __ne__(self, other):
22242 
    return not (self == other)
22243 
 
22244 
class getAllNonFbaListedItems_result:
22245 
  """
22246 
  Attributes:
22247 
   - success
22248 
  """
22249 
 
22250 
  thrift_spec = (
22251 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22252 
  )
22253 
 
22254 
  def __init__(self, success=None,):
22255 
    self.success = success
22256 
 
22257 
  def read(self, iprot):
22258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22260 
      return
22261 
    iprot.readStructBegin()
22262 
    while True:
22263 
      (fname, ftype, fid) = iprot.readFieldBegin()
22264 
      if ftype == TType.STOP:
22265 
        break
22266 
      if fid == 0:
22267 
        if ftype == TType.LIST:
22268 
          self.success = []
9155 kshitij.so 22269 
          (_etype456, _size453) = iprot.readListBegin()
22270 
          for _i457 in xrange(_size453):
22271 
            _elem458 = Amazonlisted()
22272 
            _elem458.read(iprot)
22273 
            self.success.append(_elem458)
7291 vikram.rag 22274 
          iprot.readListEnd()
22275 
        else:
22276 
          iprot.skip(ftype)
22277 
      else:
22278 
        iprot.skip(ftype)
22279 
      iprot.readFieldEnd()
22280 
    iprot.readStructEnd()
22281 
 
22282 
  def write(self, oprot):
22283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22285 
      return
22286 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
22287 
    if self.success is not None:
22288 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22289 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22290 
      for iter459 in self.success:
22291 
        iter459.write(oprot)
7291 vikram.rag 22292 
      oprot.writeListEnd()
22293 
      oprot.writeFieldEnd()
22294 
    oprot.writeFieldStop()
22295 
    oprot.writeStructEnd()
22296 
 
22297 
  def validate(self):
22298 
    return
22299 
 
22300 
 
22301 
  def __repr__(self):
22302 
    L = ['%s=%r' % (key, value)
22303 
      for key, value in self.__dict__.iteritems()]
22304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22305 
 
22306 
  def __eq__(self, other):
22307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22308 
 
22309 
  def __ne__(self, other):
22310 
    return not (self == other)
7460 kshitij.so 22311 
 
22312 
class updateItemInventory_args:
22313 
  """
22314 
  Attributes:
22315 
   - itemId
22316 
   - holdInventory
22317 
   - defaultInventory
22318 
  """
22319 
 
22320 
  thrift_spec = (
22321 
    None, # 0
22322 
    (1, TType.I64, 'itemId', None, None, ), # 1
22323 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
22324 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
22325 
  )
22326 
 
22327 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
22328 
    self.itemId = itemId
22329 
    self.holdInventory = holdInventory
22330 
    self.defaultInventory = defaultInventory
22331 
 
22332 
  def read(self, iprot):
22333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22335 
      return
22336 
    iprot.readStructBegin()
22337 
    while True:
22338 
      (fname, ftype, fid) = iprot.readFieldBegin()
22339 
      if ftype == TType.STOP:
22340 
        break
22341 
      if fid == 1:
22342 
        if ftype == TType.I64:
22343 
          self.itemId = iprot.readI64();
22344 
        else:
22345 
          iprot.skip(ftype)
22346 
      elif fid == 2:
22347 
        if ftype == TType.I64:
22348 
          self.holdInventory = iprot.readI64();
22349 
        else:
22350 
          iprot.skip(ftype)
22351 
      elif fid == 3:
22352 
        if ftype == TType.I64:
22353 
          self.defaultInventory = iprot.readI64();
22354 
        else:
22355 
          iprot.skip(ftype)
22356 
      else:
22357 
        iprot.skip(ftype)
22358 
      iprot.readFieldEnd()
22359 
    iprot.readStructEnd()
22360 
 
22361 
  def write(self, oprot):
22362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22364 
      return
22365 
    oprot.writeStructBegin('updateItemInventory_args')
22366 
    if self.itemId is not None:
22367 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22368 
      oprot.writeI64(self.itemId)
22369 
      oprot.writeFieldEnd()
22370 
    if self.holdInventory is not None:
22371 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
22372 
      oprot.writeI64(self.holdInventory)
22373 
      oprot.writeFieldEnd()
22374 
    if self.defaultInventory is not None:
22375 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
22376 
      oprot.writeI64(self.defaultInventory)
22377 
      oprot.writeFieldEnd()
22378 
    oprot.writeFieldStop()
22379 
    oprot.writeStructEnd()
22380 
 
22381 
  def validate(self):
22382 
    return
22383 
 
22384 
 
22385 
  def __repr__(self):
22386 
    L = ['%s=%r' % (key, value)
22387 
      for key, value in self.__dict__.iteritems()]
22388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22389 
 
22390 
  def __eq__(self, other):
22391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22392 
 
22393 
  def __ne__(self, other):
22394 
    return not (self == other)
22395 
 
22396 
class updateItemInventory_result:
22397 
  """
22398 
  Attributes:
22399 
   - success
22400 
  """
22401 
 
22402 
  thrift_spec = (
22403 
    (0, TType.BOOL, 'success', None, None, ), # 0
22404 
  )
22405 
 
22406 
  def __init__(self, success=None,):
22407 
    self.success = success
22408 
 
22409 
  def read(self, iprot):
22410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22412 
      return
22413 
    iprot.readStructBegin()
22414 
    while True:
22415 
      (fname, ftype, fid) = iprot.readFieldBegin()
22416 
      if ftype == TType.STOP:
22417 
        break
22418 
      if fid == 0:
22419 
        if ftype == TType.BOOL:
22420 
          self.success = iprot.readBool();
22421 
        else:
22422 
          iprot.skip(ftype)
22423 
      else:
22424 
        iprot.skip(ftype)
22425 
      iprot.readFieldEnd()
22426 
    iprot.readStructEnd()
22427 
 
22428 
  def write(self, oprot):
22429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22431 
      return
22432 
    oprot.writeStructBegin('updateItemInventory_result')
22433 
    if self.success is not None:
22434 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22435 
      oprot.writeBool(self.success)
22436 
      oprot.writeFieldEnd()
22437 
    oprot.writeFieldStop()
22438 
    oprot.writeStructEnd()
22439 
 
22440 
  def validate(self):
22441 
    return
22442 
 
22443 
 
22444 
  def __repr__(self):
22445 
    L = ['%s=%r' % (key, value)
22446 
      for key, value in self.__dict__.iteritems()]
22447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22448 
 
22449 
  def __eq__(self, other):
22450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22451 
 
22452 
  def __ne__(self, other):
22453 
    return not (self == other)
7770 kshitij.so 22454 
 
22455 
class updateTimestampForAmazonFeeds_args:
22456 
  """
22457 
  Attributes:
22458 
   - type
22459 
   - sku
22460 
   - timestamp
22461 
  """
22462 
 
22463 
  thrift_spec = (
22464 
    None, # 0
22465 
    (1, TType.STRING, 'type', None, None, ), # 1
22466 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
22467 
    (3, TType.I64, 'timestamp', None, None, ), # 3
22468 
  )
22469 
 
22470 
  def __init__(self, type=None, sku=None, timestamp=None,):
22471 
    self.type = type
22472 
    self.sku = sku
22473 
    self.timestamp = timestamp
22474 
 
22475 
  def read(self, iprot):
22476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22478 
      return
22479 
    iprot.readStructBegin()
22480 
    while True:
22481 
      (fname, ftype, fid) = iprot.readFieldBegin()
22482 
      if ftype == TType.STOP:
22483 
        break
22484 
      if fid == 1:
22485 
        if ftype == TType.STRING:
22486 
          self.type = iprot.readString();
22487 
        else:
22488 
          iprot.skip(ftype)
22489 
      elif fid == 2:
22490 
        if ftype == TType.LIST:
22491 
          self.sku = []
9155 kshitij.so 22492 
          (_etype463, _size460) = iprot.readListBegin()
22493 
          for _i464 in xrange(_size460):
22494 
            _elem465 = iprot.readI64();
22495 
            self.sku.append(_elem465)
7770 kshitij.so 22496 
          iprot.readListEnd()
22497 
        else:
22498 
          iprot.skip(ftype)
22499 
      elif fid == 3:
22500 
        if ftype == TType.I64:
22501 
          self.timestamp = iprot.readI64();
22502 
        else:
22503 
          iprot.skip(ftype)
22504 
      else:
22505 
        iprot.skip(ftype)
22506 
      iprot.readFieldEnd()
22507 
    iprot.readStructEnd()
22508 
 
22509 
  def write(self, oprot):
22510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22512 
      return
22513 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
22514 
    if self.type is not None:
22515 
      oprot.writeFieldBegin('type', TType.STRING, 1)
22516 
      oprot.writeString(self.type)
22517 
      oprot.writeFieldEnd()
22518 
    if self.sku is not None:
22519 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
22520 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 22521 
      for iter466 in self.sku:
22522 
        oprot.writeI64(iter466)
7770 kshitij.so 22523 
      oprot.writeListEnd()
22524 
      oprot.writeFieldEnd()
22525 
    if self.timestamp is not None:
22526 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
22527 
      oprot.writeI64(self.timestamp)
22528 
      oprot.writeFieldEnd()
22529 
    oprot.writeFieldStop()
22530 
    oprot.writeStructEnd()
22531 
 
22532 
  def validate(self):
22533 
    return
22534 
 
22535 
 
22536 
  def __repr__(self):
22537 
    L = ['%s=%r' % (key, value)
22538 
      for key, value in self.__dict__.iteritems()]
22539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22540 
 
22541 
  def __eq__(self, other):
22542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22543 
 
22544 
  def __ne__(self, other):
22545 
    return not (self == other)
22546 
 
22547 
class updateTimestampForAmazonFeeds_result:
22548 
  """
22549 
  Attributes:
22550 
   - success
22551 
  """
22552 
 
22553 
  thrift_spec = (
22554 
    (0, TType.BOOL, 'success', None, None, ), # 0
22555 
  )
22556 
 
22557 
  def __init__(self, success=None,):
22558 
    self.success = success
22559 
 
22560 
  def read(self, iprot):
22561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22563 
      return
22564 
    iprot.readStructBegin()
22565 
    while True:
22566 
      (fname, ftype, fid) = iprot.readFieldBegin()
22567 
      if ftype == TType.STOP:
22568 
        break
22569 
      if fid == 0:
22570 
        if ftype == TType.BOOL:
22571 
          self.success = iprot.readBool();
22572 
        else:
22573 
          iprot.skip(ftype)
22574 
      else:
22575 
        iprot.skip(ftype)
22576 
      iprot.readFieldEnd()
22577 
    iprot.readStructEnd()
22578 
 
22579 
  def write(self, oprot):
22580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22582 
      return
22583 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
22584 
    if self.success is not None:
22585 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22586 
      oprot.writeBool(self.success)
22587 
      oprot.writeFieldEnd()
22588 
    oprot.writeFieldStop()
22589 
    oprot.writeStructEnd()
22590 
 
22591 
  def validate(self):
22592 
    return
22593 
 
22594 
 
22595 
  def __repr__(self):
22596 
    L = ['%s=%r' % (key, value)
22597 
      for key, value in self.__dict__.iteritems()]
22598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22599 
 
22600 
  def __eq__(self, other):
22601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22602 
 
22603 
  def __ne__(self, other):
22604 
    return not (self == other)
7897 amar.kumar 22605 
 
22606 
class getAllParentCategories_args:
22607 
 
22608 
  thrift_spec = (
22609 
  )
22610 
 
22611 
  def read(self, iprot):
22612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22614 
      return
22615 
    iprot.readStructBegin()
22616 
    while True:
22617 
      (fname, ftype, fid) = iprot.readFieldBegin()
22618 
      if ftype == TType.STOP:
22619 
        break
22620 
      else:
22621 
        iprot.skip(ftype)
22622 
      iprot.readFieldEnd()
22623 
    iprot.readStructEnd()
22624 
 
22625 
  def write(self, oprot):
22626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22628 
      return
22629 
    oprot.writeStructBegin('getAllParentCategories_args')
22630 
    oprot.writeFieldStop()
22631 
    oprot.writeStructEnd()
22632 
 
22633 
  def validate(self):
22634 
    return
22635 
 
22636 
 
22637 
  def __repr__(self):
22638 
    L = ['%s=%r' % (key, value)
22639 
      for key, value in self.__dict__.iteritems()]
22640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22641 
 
22642 
  def __eq__(self, other):
22643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22644 
 
22645 
  def __ne__(self, other):
22646 
    return not (self == other)
22647 
 
22648 
class getAllParentCategories_result:
22649 
  """
22650 
  Attributes:
22651 
   - success
22652 
  """
22653 
 
22654 
  thrift_spec = (
22655 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
22656 
  )
22657 
 
22658 
  def __init__(self, success=None,):
22659 
    self.success = success
22660 
 
22661 
  def read(self, iprot):
22662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22664 
      return
22665 
    iprot.readStructBegin()
22666 
    while True:
22667 
      (fname, ftype, fid) = iprot.readFieldBegin()
22668 
      if ftype == TType.STOP:
22669 
        break
22670 
      if fid == 0:
22671 
        if ftype == TType.LIST:
22672 
          self.success = []
9155 kshitij.so 22673 
          (_etype470, _size467) = iprot.readListBegin()
22674 
          for _i471 in xrange(_size467):
22675 
            _elem472 = Category()
22676 
            _elem472.read(iprot)
22677 
            self.success.append(_elem472)
7897 amar.kumar 22678 
          iprot.readListEnd()
22679 
        else:
22680 
          iprot.skip(ftype)
22681 
      else:
22682 
        iprot.skip(ftype)
22683 
      iprot.readFieldEnd()
22684 
    iprot.readStructEnd()
22685 
 
22686 
  def write(self, oprot):
22687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22689 
      return
22690 
    oprot.writeStructBegin('getAllParentCategories_result')
22691 
    if self.success is not None:
22692 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22693 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22694 
      for iter473 in self.success:
22695 
        iter473.write(oprot)
7897 amar.kumar 22696 
      oprot.writeListEnd()
22697 
      oprot.writeFieldEnd()
22698 
    oprot.writeFieldStop()
22699 
    oprot.writeStructEnd()
22700 
 
22701 
  def validate(self):
22702 
    return
22703 
 
22704 
 
22705 
  def __repr__(self):
22706 
    L = ['%s=%r' % (key, value)
22707 
      for key, value in self.__dict__.iteritems()]
22708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22709 
 
22710 
  def __eq__(self, other):
22711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22712 
 
22713 
  def __ne__(self, other):
22714 
    return not (self == other)
7977 kshitij.so 22715 
 
22716 
class addPageViewEvent_args:
22717 
  """
22718 
  Attributes:
22719 
   - pageViewEvents
22720 
  """
22721 
 
22722 
  thrift_spec = (
22723 
    None, # 0
22724 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
22725 
  )
22726 
 
22727 
  def __init__(self, pageViewEvents=None,):
22728 
    self.pageViewEvents = pageViewEvents
22729 
 
22730 
  def read(self, iprot):
22731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22733 
      return
22734 
    iprot.readStructBegin()
22735 
    while True:
22736 
      (fname, ftype, fid) = iprot.readFieldBegin()
22737 
      if ftype == TType.STOP:
22738 
        break
22739 
      if fid == 1:
22740 
        if ftype == TType.STRUCT:
22741 
          self.pageViewEvents = PageViewEvents()
22742 
          self.pageViewEvents.read(iprot)
22743 
        else:
22744 
          iprot.skip(ftype)
22745 
      else:
22746 
        iprot.skip(ftype)
22747 
      iprot.readFieldEnd()
22748 
    iprot.readStructEnd()
22749 
 
22750 
  def write(self, oprot):
22751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22753 
      return
22754 
    oprot.writeStructBegin('addPageViewEvent_args')
22755 
    if self.pageViewEvents is not None:
22756 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
22757 
      self.pageViewEvents.write(oprot)
22758 
      oprot.writeFieldEnd()
22759 
    oprot.writeFieldStop()
22760 
    oprot.writeStructEnd()
22761 
 
22762 
  def validate(self):
22763 
    return
22764 
 
22765 
 
22766 
  def __repr__(self):
22767 
    L = ['%s=%r' % (key, value)
22768 
      for key, value in self.__dict__.iteritems()]
22769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22770 
 
22771 
  def __eq__(self, other):
22772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22773 
 
22774 
  def __ne__(self, other):
22775 
    return not (self == other)
22776 
 
22777 
class addPageViewEvent_result:
22778 
 
22779 
  thrift_spec = (
22780 
  )
22781 
 
22782 
  def read(self, iprot):
22783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22785 
      return
22786 
    iprot.readStructBegin()
22787 
    while True:
22788 
      (fname, ftype, fid) = iprot.readFieldBegin()
22789 
      if ftype == TType.STOP:
22790 
        break
22791 
      else:
22792 
        iprot.skip(ftype)
22793 
      iprot.readFieldEnd()
22794 
    iprot.readStructEnd()
22795 
 
22796 
  def write(self, oprot):
22797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22799 
      return
22800 
    oprot.writeStructBegin('addPageViewEvent_result')
22801 
    oprot.writeFieldStop()
22802 
    oprot.writeStructEnd()
22803 
 
22804 
  def validate(self):
22805 
    return
22806 
 
22807 
 
22808 
  def __repr__(self):
22809 
    L = ['%s=%r' % (key, value)
22810 
      for key, value in self.__dict__.iteritems()]
22811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22812 
 
22813 
  def __eq__(self, other):
22814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22815 
 
22816 
  def __ne__(self, other):
22817 
    return not (self == other)
22818 
 
22819 
class addCartEvent_args:
22820 
  """
22821 
  Attributes:
22822 
   - cartEvents
22823 
  """
22824 
 
22825 
  thrift_spec = (
22826 
    None, # 0
22827 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
22828 
  )
22829 
 
22830 
  def __init__(self, cartEvents=None,):
22831 
    self.cartEvents = cartEvents
22832 
 
22833 
  def read(self, iprot):
22834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22836 
      return
22837 
    iprot.readStructBegin()
22838 
    while True:
22839 
      (fname, ftype, fid) = iprot.readFieldBegin()
22840 
      if ftype == TType.STOP:
22841 
        break
22842 
      if fid == 1:
22843 
        if ftype == TType.STRUCT:
22844 
          self.cartEvents = CartEvents()
22845 
          self.cartEvents.read(iprot)
22846 
        else:
22847 
          iprot.skip(ftype)
22848 
      else:
22849 
        iprot.skip(ftype)
22850 
      iprot.readFieldEnd()
22851 
    iprot.readStructEnd()
22852 
 
22853 
  def write(self, oprot):
22854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22856 
      return
22857 
    oprot.writeStructBegin('addCartEvent_args')
22858 
    if self.cartEvents is not None:
22859 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
22860 
      self.cartEvents.write(oprot)
22861 
      oprot.writeFieldEnd()
22862 
    oprot.writeFieldStop()
22863 
    oprot.writeStructEnd()
22864 
 
22865 
  def validate(self):
22866 
    return
22867 
 
22868 
 
22869 
  def __repr__(self):
22870 
    L = ['%s=%r' % (key, value)
22871 
      for key, value in self.__dict__.iteritems()]
22872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22873 
 
22874 
  def __eq__(self, other):
22875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22876 
 
22877 
  def __ne__(self, other):
22878 
    return not (self == other)
22879 
 
22880 
class addCartEvent_result:
22881 
 
22882 
  thrift_spec = (
22883 
  )
22884 
 
22885 
  def read(self, iprot):
22886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22888 
      return
22889 
    iprot.readStructBegin()
22890 
    while True:
22891 
      (fname, ftype, fid) = iprot.readFieldBegin()
22892 
      if ftype == TType.STOP:
22893 
        break
22894 
      else:
22895 
        iprot.skip(ftype)
22896 
      iprot.readFieldEnd()
22897 
    iprot.readStructEnd()
22898 
 
22899 
  def write(self, oprot):
22900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22902 
      return
22903 
    oprot.writeStructBegin('addCartEvent_result')
22904 
    oprot.writeFieldStop()
22905 
    oprot.writeStructEnd()
22906 
 
22907 
  def validate(self):
22908 
    return
22909 
 
22910 
 
22911 
  def __repr__(self):
22912 
    L = ['%s=%r' % (key, value)
22913 
      for key, value in self.__dict__.iteritems()]
22914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22915 
 
22916 
  def __eq__(self, other):
22917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22918 
 
22919 
  def __ne__(self, other):
22920 
    return not (self == other)
8139 kshitij.so 22921 
 
8182 amar.kumar 22922 
class addEbayItem_args:
22923 
  """
22924 
  Attributes:
22925 
   - ebayItem
22926 
  """
22927 
 
22928 
  thrift_spec = (
22929 
    None, # 0
22930 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22931 
  )
22932 
 
22933 
  def __init__(self, ebayItem=None,):
22934 
    self.ebayItem = ebayItem
22935 
 
22936 
  def read(self, iprot):
22937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22939 
      return
22940 
    iprot.readStructBegin()
22941 
    while True:
22942 
      (fname, ftype, fid) = iprot.readFieldBegin()
22943 
      if ftype == TType.STOP:
22944 
        break
22945 
      if fid == 1:
22946 
        if ftype == TType.STRUCT:
22947 
          self.ebayItem = EbayItem()
22948 
          self.ebayItem.read(iprot)
22949 
        else:
22950 
          iprot.skip(ftype)
22951 
      else:
22952 
        iprot.skip(ftype)
22953 
      iprot.readFieldEnd()
22954 
    iprot.readStructEnd()
22955 
 
22956 
  def write(self, oprot):
22957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22959 
      return
22960 
    oprot.writeStructBegin('addEbayItem_args')
22961 
    if self.ebayItem is not None:
22962 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22963 
      self.ebayItem.write(oprot)
22964 
      oprot.writeFieldEnd()
22965 
    oprot.writeFieldStop()
22966 
    oprot.writeStructEnd()
22967 
 
22968 
  def validate(self):
22969 
    return
22970 
 
22971 
 
22972 
  def __repr__(self):
22973 
    L = ['%s=%r' % (key, value)
22974 
      for key, value in self.__dict__.iteritems()]
22975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22976 
 
22977 
  def __eq__(self, other):
22978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22979 
 
22980 
  def __ne__(self, other):
22981 
    return not (self == other)
22982 
 
22983 
class addEbayItem_result:
22984 
 
22985 
  thrift_spec = (
22986 
  )
22987 
 
22988 
  def read(self, iprot):
22989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22991 
      return
22992 
    iprot.readStructBegin()
22993 
    while True:
22994 
      (fname, ftype, fid) = iprot.readFieldBegin()
22995 
      if ftype == TType.STOP:
22996 
        break
22997 
      else:
22998 
        iprot.skip(ftype)
22999 
      iprot.readFieldEnd()
23000 
    iprot.readStructEnd()
23001 
 
23002 
  def write(self, oprot):
23003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23005 
      return
23006 
    oprot.writeStructBegin('addEbayItem_result')
23007 
    oprot.writeFieldStop()
23008 
    oprot.writeStructEnd()
23009 
 
23010 
  def validate(self):
23011 
    return
23012 
 
23013 
 
23014 
  def __repr__(self):
23015 
    L = ['%s=%r' % (key, value)
23016 
      for key, value in self.__dict__.iteritems()]
23017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23018 
 
23019 
  def __eq__(self, other):
23020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23021 
 
23022 
  def __ne__(self, other):
23023 
    return not (self == other)
23024 
 
23025 
class getEbayItem_args:
23026 
  """
23027 
  Attributes:
23028 
   - listingId
23029 
  """
23030 
 
23031 
  thrift_spec = (
23032 
    None, # 0
23033 
    (1, TType.STRING, 'listingId', None, None, ), # 1
23034 
  )
23035 
 
23036 
  def __init__(self, listingId=None,):
23037 
    self.listingId = listingId
23038 
 
23039 
  def read(self, iprot):
23040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23042 
      return
23043 
    iprot.readStructBegin()
23044 
    while True:
23045 
      (fname, ftype, fid) = iprot.readFieldBegin()
23046 
      if ftype == TType.STOP:
23047 
        break
23048 
      if fid == 1:
23049 
        if ftype == TType.STRING:
23050 
          self.listingId = iprot.readString();
23051 
        else:
23052 
          iprot.skip(ftype)
23053 
      else:
23054 
        iprot.skip(ftype)
23055 
      iprot.readFieldEnd()
23056 
    iprot.readStructEnd()
23057 
 
23058 
  def write(self, oprot):
23059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23061 
      return
23062 
    oprot.writeStructBegin('getEbayItem_args')
23063 
    if self.listingId is not None:
23064 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
23065 
      oprot.writeString(self.listingId)
23066 
      oprot.writeFieldEnd()
23067 
    oprot.writeFieldStop()
23068 
    oprot.writeStructEnd()
23069 
 
23070 
  def validate(self):
23071 
    return
23072 
 
23073 
 
23074 
  def __repr__(self):
23075 
    L = ['%s=%r' % (key, value)
23076 
      for key, value in self.__dict__.iteritems()]
23077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23078 
 
23079 
  def __eq__(self, other):
23080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23081 
 
23082 
  def __ne__(self, other):
23083 
    return not (self == other)
23084 
 
23085 
class getEbayItem_result:
23086 
  """
23087 
  Attributes:
23088 
   - success
23089 
  """
23090 
 
23091 
  thrift_spec = (
23092 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
23093 
  )
23094 
 
23095 
  def __init__(self, success=None,):
23096 
    self.success = success
23097 
 
23098 
  def read(self, iprot):
23099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23101 
      return
23102 
    iprot.readStructBegin()
23103 
    while True:
23104 
      (fname, ftype, fid) = iprot.readFieldBegin()
23105 
      if ftype == TType.STOP:
23106 
        break
23107 
      if fid == 0:
23108 
        if ftype == TType.STRUCT:
23109 
          self.success = EbayItem()
23110 
          self.success.read(iprot)
23111 
        else:
23112 
          iprot.skip(ftype)
23113 
      else:
23114 
        iprot.skip(ftype)
23115 
      iprot.readFieldEnd()
23116 
    iprot.readStructEnd()
23117 
 
23118 
  def write(self, oprot):
23119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23121 
      return
23122 
    oprot.writeStructBegin('getEbayItem_result')
23123 
    if self.success is not None:
23124 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23125 
      self.success.write(oprot)
23126 
      oprot.writeFieldEnd()
23127 
    oprot.writeFieldStop()
23128 
    oprot.writeStructEnd()
23129 
 
23130 
  def validate(self):
23131 
    return
23132 
 
23133 
 
23134 
  def __repr__(self):
23135 
    L = ['%s=%r' % (key, value)
23136 
      for key, value in self.__dict__.iteritems()]
23137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23138 
 
23139 
  def __eq__(self, other):
23140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23141 
 
23142 
  def __ne__(self, other):
23143 
    return not (self == other)
23144 
 
23145 
class updateEbayItem_args:
23146 
  """
23147 
  Attributes:
23148 
   - ebayItem
23149 
  """
23150 
 
23151 
  thrift_spec = (
23152 
    None, # 0
23153 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
23154 
  )
23155 
 
23156 
  def __init__(self, ebayItem=None,):
23157 
    self.ebayItem = ebayItem
23158 
 
23159 
  def read(self, iprot):
23160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23162 
      return
23163 
    iprot.readStructBegin()
23164 
    while True:
23165 
      (fname, ftype, fid) = iprot.readFieldBegin()
23166 
      if ftype == TType.STOP:
23167 
        break
23168 
      if fid == 1:
23169 
        if ftype == TType.STRUCT:
23170 
          self.ebayItem = EbayItem()
23171 
          self.ebayItem.read(iprot)
23172 
        else:
23173 
          iprot.skip(ftype)
23174 
      else:
23175 
        iprot.skip(ftype)
23176 
      iprot.readFieldEnd()
23177 
    iprot.readStructEnd()
23178 
 
23179 
  def write(self, oprot):
23180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23182 
      return
23183 
    oprot.writeStructBegin('updateEbayItem_args')
23184 
    if self.ebayItem is not None:
23185 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
23186 
      self.ebayItem.write(oprot)
23187 
      oprot.writeFieldEnd()
23188 
    oprot.writeFieldStop()
23189 
    oprot.writeStructEnd()
23190 
 
23191 
  def validate(self):
23192 
    return
23193 
 
23194 
 
23195 
  def __repr__(self):
23196 
    L = ['%s=%r' % (key, value)
23197 
      for key, value in self.__dict__.iteritems()]
23198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23199 
 
23200 
  def __eq__(self, other):
23201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23202 
 
23203 
  def __ne__(self, other):
23204 
    return not (self == other)
23205 
 
23206 
class updateEbayItem_result:
23207 
 
23208 
  thrift_spec = (
23209 
  )
23210 
 
23211 
  def read(self, iprot):
23212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23214 
      return
23215 
    iprot.readStructBegin()
23216 
    while True:
23217 
      (fname, ftype, fid) = iprot.readFieldBegin()
23218 
      if ftype == TType.STOP:
23219 
        break
23220 
      else:
23221 
        iprot.skip(ftype)
23222 
      iprot.readFieldEnd()
23223 
    iprot.readStructEnd()
23224 
 
23225 
  def write(self, oprot):
23226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23228 
      return
23229 
    oprot.writeStructBegin('updateEbayItem_result')
23230 
    oprot.writeFieldStop()
23231 
    oprot.writeStructEnd()
23232 
 
23233 
  def validate(self):
23234 
    return
23235 
 
23236 
 
23237 
  def __repr__(self):
23238 
    L = ['%s=%r' % (key, value)
23239 
      for key, value in self.__dict__.iteritems()]
23240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23241 
 
23242 
  def __eq__(self, other):
23243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23244 
 
23245 
  def __ne__(self, other):
23246 
    return not (self == other)
23247 
 
8139 kshitij.so 23248 
class getAmazonListedItems_args:
23249 
  """
23250 
  Attributes:
23251 
   - offset
23252 
   - limit
23253 
  """
23254 
 
23255 
  thrift_spec = (
23256 
    None, # 0
23257 
    (1, TType.I64, 'offset', None, None, ), # 1
23258 
    (2, TType.I64, 'limit', None, None, ), # 2
23259 
  )
23260 
 
23261 
  def __init__(self, offset=None, limit=None,):
23262 
    self.offset = offset
23263 
    self.limit = limit
23264 
 
23265 
  def read(self, iprot):
23266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23268 
      return
23269 
    iprot.readStructBegin()
23270 
    while True:
23271 
      (fname, ftype, fid) = iprot.readFieldBegin()
23272 
      if ftype == TType.STOP:
23273 
        break
23274 
      if fid == 1:
23275 
        if ftype == TType.I64:
23276 
          self.offset = iprot.readI64();
23277 
        else:
23278 
          iprot.skip(ftype)
23279 
      elif fid == 2:
23280 
        if ftype == TType.I64:
23281 
          self.limit = iprot.readI64();
23282 
        else:
23283 
          iprot.skip(ftype)
23284 
      else:
23285 
        iprot.skip(ftype)
23286 
      iprot.readFieldEnd()
23287 
    iprot.readStructEnd()
23288 
 
23289 
  def write(self, oprot):
23290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23292 
      return
23293 
    oprot.writeStructBegin('getAmazonListedItems_args')
23294 
    if self.offset is not None:
23295 
      oprot.writeFieldBegin('offset', TType.I64, 1)
23296 
      oprot.writeI64(self.offset)
23297 
      oprot.writeFieldEnd()
23298 
    if self.limit is not None:
23299 
      oprot.writeFieldBegin('limit', TType.I64, 2)
23300 
      oprot.writeI64(self.limit)
23301 
      oprot.writeFieldEnd()
23302 
    oprot.writeFieldStop()
23303 
    oprot.writeStructEnd()
23304 
 
23305 
  def validate(self):
23306 
    return
23307 
 
23308 
 
23309 
  def __repr__(self):
23310 
    L = ['%s=%r' % (key, value)
23311 
      for key, value in self.__dict__.iteritems()]
23312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23313 
 
23314 
  def __eq__(self, other):
23315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23316 
 
23317 
  def __ne__(self, other):
23318 
    return not (self == other)
23319 
 
23320 
class getAmazonListedItems_result:
23321 
  """
23322 
  Attributes:
23323 
   - success
23324 
  """
23325 
 
23326 
  thrift_spec = (
23327 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23328 
  )
23329 
 
23330 
  def __init__(self, success=None,):
23331 
    self.success = success
23332 
 
23333 
  def read(self, iprot):
23334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23336 
      return
23337 
    iprot.readStructBegin()
23338 
    while True:
23339 
      (fname, ftype, fid) = iprot.readFieldBegin()
23340 
      if ftype == TType.STOP:
23341 
        break
23342 
      if fid == 0:
23343 
        if ftype == TType.LIST:
23344 
          self.success = []
9155 kshitij.so 23345 
          (_etype477, _size474) = iprot.readListBegin()
23346 
          for _i478 in xrange(_size474):
23347 
            _elem479 = Amazonlisted()
23348 
            _elem479.read(iprot)
23349 
            self.success.append(_elem479)
8139 kshitij.so 23350 
          iprot.readListEnd()
23351 
        else:
23352 
          iprot.skip(ftype)
23353 
      else:
23354 
        iprot.skip(ftype)
23355 
      iprot.readFieldEnd()
23356 
    iprot.readStructEnd()
23357 
 
23358 
  def write(self, oprot):
23359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23361 
      return
23362 
    oprot.writeStructBegin('getAmazonListedItems_result')
23363 
    if self.success is not None:
23364 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23365 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23366 
      for iter480 in self.success:
23367 
        iter480.write(oprot)
8139 kshitij.so 23368 
      oprot.writeListEnd()
23369 
      oprot.writeFieldEnd()
23370 
    oprot.writeFieldStop()
23371 
    oprot.writeStructEnd()
23372 
 
23373 
  def validate(self):
23374 
    return
23375 
 
23376 
 
23377 
  def __repr__(self):
23378 
    L = ['%s=%r' % (key, value)
23379 
      for key, value in self.__dict__.iteritems()]
23380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23381 
 
23382 
  def __eq__(self, other):
23383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23384 
 
23385 
  def __ne__(self, other):
23386 
    return not (self == other)
8168 kshitij.so 23387 
 
23388 
class updateAmazonAttributesInBulk_args:
23389 
  """
23390 
  Attributes:
23391 
   - amazonlisted
23392 
  """
23393 
 
23394 
  thrift_spec = (
23395 
    None, # 0
23396 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
23397 
  )
23398 
 
23399 
  def __init__(self, amazonlisted=None,):
23400 
    self.amazonlisted = amazonlisted
23401 
 
23402 
  def read(self, iprot):
23403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23405 
      return
23406 
    iprot.readStructBegin()
23407 
    while True:
23408 
      (fname, ftype, fid) = iprot.readFieldBegin()
23409 
      if ftype == TType.STOP:
23410 
        break
23411 
      if fid == 1:
23412 
        if ftype == TType.MAP:
23413 
          self.amazonlisted = {}
9155 kshitij.so 23414 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
23415 
          for _i485 in xrange(_size481):
23416 
            _key486 = iprot.readI64();
23417 
            _val487 = Amazonlisted()
23418 
            _val487.read(iprot)
23419 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 23420 
          iprot.readMapEnd()
23421 
        else:
23422 
          iprot.skip(ftype)
23423 
      else:
23424 
        iprot.skip(ftype)
23425 
      iprot.readFieldEnd()
23426 
    iprot.readStructEnd()
23427 
 
23428 
  def write(self, oprot):
23429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23431 
      return
23432 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
23433 
    if self.amazonlisted is not None:
23434 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
23435 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 23436 
      for kiter488,viter489 in self.amazonlisted.items():
23437 
        oprot.writeI64(kiter488)
23438 
        viter489.write(oprot)
8168 kshitij.so 23439 
      oprot.writeMapEnd()
23440 
      oprot.writeFieldEnd()
23441 
    oprot.writeFieldStop()
23442 
    oprot.writeStructEnd()
23443 
 
23444 
  def validate(self):
23445 
    return
23446 
 
23447 
 
23448 
  def __repr__(self):
23449 
    L = ['%s=%r' % (key, value)
23450 
      for key, value in self.__dict__.iteritems()]
23451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23452 
 
23453 
  def __eq__(self, other):
23454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23455 
 
23456 
  def __ne__(self, other):
23457 
    return not (self == other)
23458 
 
23459 
class updateAmazonAttributesInBulk_result:
23460 
  """
23461 
  Attributes:
23462 
   - success
23463 
  """
23464 
 
23465 
  thrift_spec = (
23466 
    (0, TType.BOOL, 'success', None, None, ), # 0
23467 
  )
23468 
 
23469 
  def __init__(self, success=None,):
23470 
    self.success = success
23471 
 
23472 
  def read(self, iprot):
23473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23475 
      return
23476 
    iprot.readStructBegin()
23477 
    while True:
23478 
      (fname, ftype, fid) = iprot.readFieldBegin()
23479 
      if ftype == TType.STOP:
23480 
        break
23481 
      if fid == 0:
23482 
        if ftype == TType.BOOL:
23483 
          self.success = iprot.readBool();
23484 
        else:
23485 
          iprot.skip(ftype)
23486 
      else:
23487 
        iprot.skip(ftype)
23488 
      iprot.readFieldEnd()
23489 
    iprot.readStructEnd()
23490 
 
23491 
  def write(self, oprot):
23492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23494 
      return
23495 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
23496 
    if self.success is not None:
23497 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23498 
      oprot.writeBool(self.success)
23499 
      oprot.writeFieldEnd()
23500 
    oprot.writeFieldStop()
23501 
    oprot.writeStructEnd()
23502 
 
23503 
  def validate(self):
23504 
    return
23505 
 
23506 
 
23507 
  def __repr__(self):
23508 
    L = ['%s=%r' % (key, value)
23509 
      for key, value in self.__dict__.iteritems()]
23510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23511 
 
23512 
  def __eq__(self, other):
23513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23514 
 
23515 
  def __ne__(self, other):
23516 
    return not (self == other)
8379 vikram.rag 23517 
 
23518 
class getAllItemstoListOnFba_args:
23519 
 
23520 
  thrift_spec = (
23521 
  )
23522 
 
23523 
  def read(self, iprot):
23524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23526 
      return
23527 
    iprot.readStructBegin()
23528 
    while True:
23529 
      (fname, ftype, fid) = iprot.readFieldBegin()
23530 
      if ftype == TType.STOP:
23531 
        break
23532 
      else:
23533 
        iprot.skip(ftype)
23534 
      iprot.readFieldEnd()
23535 
    iprot.readStructEnd()
23536 
 
23537 
  def write(self, oprot):
23538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23540 
      return
23541 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
23542 
    oprot.writeFieldStop()
23543 
    oprot.writeStructEnd()
23544 
 
23545 
  def validate(self):
23546 
    return
23547 
 
23548 
 
23549 
  def __repr__(self):
23550 
    L = ['%s=%r' % (key, value)
23551 
      for key, value in self.__dict__.iteritems()]
23552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23553 
 
23554 
  def __eq__(self, other):
23555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23556 
 
23557 
  def __ne__(self, other):
23558 
    return not (self == other)
23559 
 
23560 
class getAllItemstoListOnFba_result:
23561 
  """
23562 
  Attributes:
23563 
   - success
23564 
  """
23565 
 
23566 
  thrift_spec = (
23567 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23568 
  )
23569 
 
23570 
  def __init__(self, success=None,):
23571 
    self.success = success
23572 
 
23573 
  def read(self, iprot):
23574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23576 
      return
23577 
    iprot.readStructBegin()
23578 
    while True:
23579 
      (fname, ftype, fid) = iprot.readFieldBegin()
23580 
      if ftype == TType.STOP:
23581 
        break
23582 
      if fid == 0:
23583 
        if ftype == TType.LIST:
23584 
          self.success = []
9155 kshitij.so 23585 
          (_etype493, _size490) = iprot.readListBegin()
23586 
          for _i494 in xrange(_size490):
23587 
            _elem495 = Amazonlisted()
23588 
            _elem495.read(iprot)
23589 
            self.success.append(_elem495)
8379 vikram.rag 23590 
          iprot.readListEnd()
23591 
        else:
23592 
          iprot.skip(ftype)
23593 
      else:
23594 
        iprot.skip(ftype)
23595 
      iprot.readFieldEnd()
23596 
    iprot.readStructEnd()
23597 
 
23598 
  def write(self, oprot):
23599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23601 
      return
23602 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
23603 
    if self.success is not None:
23604 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23605 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23606 
      for iter496 in self.success:
23607 
        iter496.write(oprot)
8379 vikram.rag 23608 
      oprot.writeListEnd()
23609 
      oprot.writeFieldEnd()
23610 
    oprot.writeFieldStop()
23611 
    oprot.writeStructEnd()
23612 
 
23613 
  def validate(self):
23614 
    return
23615 
 
23616 
 
23617 
  def __repr__(self):
23618 
    L = ['%s=%r' % (key, value)
23619 
      for key, value in self.__dict__.iteritems()]
23620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23621 
 
23622 
  def __eq__(self, other):
23623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23624 
 
23625 
  def __ne__(self, other):
23626 
    return not (self == other)
23627 
 
23628 
class getAllItemstoListOnNonFba_args:
23629 
 
23630 
  thrift_spec = (
23631 
  )
23632 
 
23633 
  def read(self, iprot):
23634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23636 
      return
23637 
    iprot.readStructBegin()
23638 
    while True:
23639 
      (fname, ftype, fid) = iprot.readFieldBegin()
23640 
      if ftype == TType.STOP:
23641 
        break
23642 
      else:
23643 
        iprot.skip(ftype)
23644 
      iprot.readFieldEnd()
23645 
    iprot.readStructEnd()
23646 
 
23647 
  def write(self, oprot):
23648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23650 
      return
23651 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
23652 
    oprot.writeFieldStop()
23653 
    oprot.writeStructEnd()
23654 
 
23655 
  def validate(self):
23656 
    return
23657 
 
23658 
 
23659 
  def __repr__(self):
23660 
    L = ['%s=%r' % (key, value)
23661 
      for key, value in self.__dict__.iteritems()]
23662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23663 
 
23664 
  def __eq__(self, other):
23665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23666 
 
23667 
  def __ne__(self, other):
23668 
    return not (self == other)
23669 
 
23670 
class getAllItemstoListOnNonFba_result:
23671 
  """
23672 
  Attributes:
23673 
   - success
23674 
  """
23675 
 
23676 
  thrift_spec = (
23677 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23678 
  )
23679 
 
23680 
  def __init__(self, success=None,):
23681 
    self.success = success
23682 
 
23683 
  def read(self, iprot):
23684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23686 
      return
23687 
    iprot.readStructBegin()
23688 
    while True:
23689 
      (fname, ftype, fid) = iprot.readFieldBegin()
23690 
      if ftype == TType.STOP:
23691 
        break
23692 
      if fid == 0:
23693 
        if ftype == TType.LIST:
23694 
          self.success = []
9155 kshitij.so 23695 
          (_etype500, _size497) = iprot.readListBegin()
23696 
          for _i501 in xrange(_size497):
23697 
            _elem502 = Amazonlisted()
23698 
            _elem502.read(iprot)
23699 
            self.success.append(_elem502)
8379 vikram.rag 23700 
          iprot.readListEnd()
23701 
        else:
23702 
          iprot.skip(ftype)
23703 
      else:
23704 
        iprot.skip(ftype)
23705 
      iprot.readFieldEnd()
23706 
    iprot.readStructEnd()
23707 
 
23708 
  def write(self, oprot):
23709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23711 
      return
23712 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
23713 
    if self.success is not None:
23714 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23715 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23716 
      for iter503 in self.success:
23717 
        iter503.write(oprot)
8379 vikram.rag 23718 
      oprot.writeListEnd()
23719 
      oprot.writeFieldEnd()
23720 
    oprot.writeFieldStop()
23721 
    oprot.writeStructEnd()
23722 
 
23723 
  def validate(self):
23724 
    return
23725 
 
23726 
 
23727 
  def __repr__(self):
23728 
    L = ['%s=%r' % (key, value)
23729 
      for key, value in self.__dict__.iteritems()]
23730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23731 
 
23732 
  def __eq__(self, other):
23733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23734 
 
23735 
  def __ne__(self, other):
23736 
    return not (self == other)
8616 vikram.rag 23737 
 
9242 kshitij.so 23738 
class updateAsin_args:
23739 
  """
23740 
  Attributes:
23741 
   - item
23742 
  """
8616 vikram.rag 23743 
 
23744 
  thrift_spec = (
9242 kshitij.so 23745 
    None, # 0
23746 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 23747 
  )
23748 
 
9242 kshitij.so 23749 
  def __init__(self, item=None,):
23750 
    self.item = item
23751 
 
8616 vikram.rag 23752 
  def read(self, iprot):
23753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23755 
      return
23756 
    iprot.readStructBegin()
23757 
    while True:
23758 
      (fname, ftype, fid) = iprot.readFieldBegin()
23759 
      if ftype == TType.STOP:
23760 
        break
9242 kshitij.so 23761 
      if fid == 1:
23762 
        if ftype == TType.MAP:
23763 
          self.item = {}
23764 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
23765 
          for _i508 in xrange(_size504):
23766 
            _key509 = iprot.readI64();
23767 
            _val510 = Item()
23768 
            _val510.read(iprot)
23769 
            self.item[_key509] = _val510
23770 
          iprot.readMapEnd()
23771 
        else:
23772 
          iprot.skip(ftype)
8616 vikram.rag 23773 
      else:
23774 
        iprot.skip(ftype)
23775 
      iprot.readFieldEnd()
23776 
    iprot.readStructEnd()
23777 
 
23778 
  def write(self, oprot):
23779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23781 
      return
9242 kshitij.so 23782 
    oprot.writeStructBegin('updateAsin_args')
23783 
    if self.item is not None:
23784 
      oprot.writeFieldBegin('item', TType.MAP, 1)
23785 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
23786 
      for kiter511,viter512 in self.item.items():
23787 
        oprot.writeI64(kiter511)
23788 
        viter512.write(oprot)
23789 
      oprot.writeMapEnd()
23790 
      oprot.writeFieldEnd()
8616 vikram.rag 23791 
    oprot.writeFieldStop()
23792 
    oprot.writeStructEnd()
23793 
 
23794 
  def validate(self):
23795 
    return
23796 
 
23797 
 
23798 
  def __repr__(self):
23799 
    L = ['%s=%r' % (key, value)
23800 
      for key, value in self.__dict__.iteritems()]
23801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23802 
 
23803 
  def __eq__(self, other):
23804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23805 
 
23806 
  def __ne__(self, other):
23807 
    return not (self == other)
23808 
 
9242 kshitij.so 23809 
class updateAsin_result:
8616 vikram.rag 23810 
 
23811 
  thrift_spec = (
23812 
  )
23813 
 
23814 
  def read(self, iprot):
23815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23817 
      return
23818 
    iprot.readStructBegin()
23819 
    while True:
23820 
      (fname, ftype, fid) = iprot.readFieldBegin()
23821 
      if ftype == TType.STOP:
23822 
        break
23823 
      else:
23824 
        iprot.skip(ftype)
23825 
      iprot.readFieldEnd()
23826 
    iprot.readStructEnd()
23827 
 
23828 
  def write(self, oprot):
23829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23831 
      return
9242 kshitij.so 23832 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 23833 
    oprot.writeFieldStop()
23834 
    oprot.writeStructEnd()
23835 
 
23836 
  def validate(self):
23837 
    return
23838 
 
23839 
 
23840 
  def __repr__(self):
23841 
    L = ['%s=%r' % (key, value)
23842 
      for key, value in self.__dict__.iteritems()]
23843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23844 
 
23845 
  def __eq__(self, other):
23846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23847 
 
23848 
  def __ne__(self, other):
23849 
    return not (self == other)
8619 kshitij.so 23850 
 
9242 kshitij.so 23851 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 23852 
  """
23853 
  Attributes:
9242 kshitij.so 23854 
   - snapdealitem
8619 kshitij.so 23855 
  """
23856 
 
9242 kshitij.so 23857 
  thrift_spec = None
23858 
  def __init__(self, snapdealitem=None,):
23859 
    self.snapdealitem = snapdealitem
8619 kshitij.so 23860 
 
23861 
  def read(self, iprot):
23862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23864 
      return
23865 
    iprot.readStructBegin()
23866 
    while True:
23867 
      (fname, ftype, fid) = iprot.readFieldBegin()
23868 
      if ftype == TType.STOP:
23869 
        break
9242 kshitij.so 23870 
      if fid == -1:
23871 
        if ftype == TType.STRUCT:
23872 
          self.snapdealitem = SnapdealItem()
23873 
          self.snapdealitem.read(iprot)
8619 kshitij.so 23874 
        else:
23875 
          iprot.skip(ftype)
23876 
      else:
23877 
        iprot.skip(ftype)
23878 
      iprot.readFieldEnd()
23879 
    iprot.readStructEnd()
23880 
 
23881 
  def write(self, oprot):
23882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23884 
      return
9242 kshitij.so 23885 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
23886 
    if self.snapdealitem is not None:
23887 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
23888 
      self.snapdealitem.write(oprot)
8619 kshitij.so 23889 
      oprot.writeFieldEnd()
23890 
    oprot.writeFieldStop()
23891 
    oprot.writeStructEnd()
23892 
 
23893 
  def validate(self):
23894 
    return
23895 
 
23896 
 
23897 
  def __repr__(self):
23898 
    L = ['%s=%r' % (key, value)
23899 
      for key, value in self.__dict__.iteritems()]
23900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23901 
 
23902 
  def __eq__(self, other):
23903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23904 
 
23905 
  def __ne__(self, other):
23906 
    return not (self == other)
23907 
 
9242 kshitij.so 23908 
class addOrUpdateSnapdealItem_result:
23909 
  """
23910 
  Attributes:
23911 
   - success
23912 
  """
8619 kshitij.so 23913 
 
23914 
  thrift_spec = (
9242 kshitij.so 23915 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 23916 
  )
23917 
 
9242 kshitij.so 23918 
  def __init__(self, success=None,):
23919 
    self.success = success
23920 
 
8619 kshitij.so 23921 
  def read(self, iprot):
23922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23924 
      return
23925 
    iprot.readStructBegin()
23926 
    while True:
23927 
      (fname, ftype, fid) = iprot.readFieldBegin()
23928 
      if ftype == TType.STOP:
23929 
        break
9242 kshitij.so 23930 
      if fid == 0:
23931 
        if ftype == TType.BOOL:
23932 
          self.success = iprot.readBool();
23933 
        else:
23934 
          iprot.skip(ftype)
8619 kshitij.so 23935 
      else:
23936 
        iprot.skip(ftype)
23937 
      iprot.readFieldEnd()
23938 
    iprot.readStructEnd()
23939 
 
23940 
  def write(self, oprot):
23941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23943 
      return
9242 kshitij.so 23944 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
23945 
    if self.success is not None:
23946 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23947 
      oprot.writeBool(self.success)
23948 
      oprot.writeFieldEnd()
8619 kshitij.so 23949 
    oprot.writeFieldStop()
23950 
    oprot.writeStructEnd()
23951 
 
23952 
  def validate(self):
23953 
    return
23954 
 
23955 
 
23956 
  def __repr__(self):
23957 
    L = ['%s=%r' % (key, value)
23958 
      for key, value in self.__dict__.iteritems()]
23959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23960 
 
23961 
  def __eq__(self, other):
23962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23963 
 
23964 
  def __ne__(self, other):
23965 
    return not (self == other)
8739 vikram.rag 23966 
 
9242 kshitij.so 23967 
class getSnapdealItem_args:
8739 vikram.rag 23968 
  """
23969 
  Attributes:
9242 kshitij.so 23970 
   - item_id
8739 vikram.rag 23971 
  """
23972 
 
9242 kshitij.so 23973 
  thrift_spec = (
23974 
    None, # 0
23975 
    (1, TType.I64, 'item_id', None, None, ), # 1
23976 
  )
8739 vikram.rag 23977 
 
9242 kshitij.so 23978 
  def __init__(self, item_id=None,):
23979 
    self.item_id = item_id
23980 
 
8739 vikram.rag 23981 
  def read(self, iprot):
23982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23984 
      return
23985 
    iprot.readStructBegin()
23986 
    while True:
23987 
      (fname, ftype, fid) = iprot.readFieldBegin()
23988 
      if ftype == TType.STOP:
23989 
        break
9242 kshitij.so 23990 
      if fid == 1:
23991 
        if ftype == TType.I64:
23992 
          self.item_id = iprot.readI64();
8739 vikram.rag 23993 
        else:
23994 
          iprot.skip(ftype)
23995 
      else:
23996 
        iprot.skip(ftype)
23997 
      iprot.readFieldEnd()
23998 
    iprot.readStructEnd()
23999 
 
24000 
  def write(self, oprot):
24001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24003 
      return
9242 kshitij.so 24004 
    oprot.writeStructBegin('getSnapdealItem_args')
24005 
    if self.item_id is not None:
24006 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
24007 
      oprot.writeI64(self.item_id)
8739 vikram.rag 24008 
      oprot.writeFieldEnd()
24009 
    oprot.writeFieldStop()
24010 
    oprot.writeStructEnd()
24011 
 
24012 
  def validate(self):
24013 
    return
24014 
 
24015 
 
24016 
  def __repr__(self):
24017 
    L = ['%s=%r' % (key, value)
24018 
      for key, value in self.__dict__.iteritems()]
24019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24020 
 
24021 
  def __eq__(self, other):
24022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24023 
 
24024 
  def __ne__(self, other):
24025 
    return not (self == other)
24026 
 
9242 kshitij.so 24027 
class getSnapdealItem_result:
8739 vikram.rag 24028 
  """
24029 
  Attributes:
24030 
   - success
24031 
  """
24032 
 
24033 
  thrift_spec = (
9242 kshitij.so 24034 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 24035 
  )
24036 
 
24037 
  def __init__(self, success=None,):
24038 
    self.success = success
24039 
 
24040 
  def read(self, iprot):
24041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24043 
      return
24044 
    iprot.readStructBegin()
24045 
    while True:
24046 
      (fname, ftype, fid) = iprot.readFieldBegin()
24047 
      if ftype == TType.STOP:
24048 
        break
24049 
      if fid == 0:
9242 kshitij.so 24050 
        if ftype == TType.STRUCT:
24051 
          self.success = SnapdealItem()
24052 
          self.success.read(iprot)
8739 vikram.rag 24053 
        else:
24054 
          iprot.skip(ftype)
24055 
      else:
24056 
        iprot.skip(ftype)
24057 
      iprot.readFieldEnd()
24058 
    iprot.readStructEnd()
24059 
 
24060 
  def write(self, oprot):
24061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24063 
      return
9242 kshitij.so 24064 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 24065 
    if self.success is not None:
9242 kshitij.so 24066 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24067 
      self.success.write(oprot)
8739 vikram.rag 24068 
      oprot.writeFieldEnd()
24069 
    oprot.writeFieldStop()
24070 
    oprot.writeStructEnd()
24071 
 
24072 
  def validate(self):
24073 
    return
24074 
 
24075 
 
24076 
  def __repr__(self):
24077 
    L = ['%s=%r' % (key, value)
24078 
      for key, value in self.__dict__.iteritems()]
24079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24080 
 
24081 
  def __eq__(self, other):
24082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24083 
 
24084 
  def __ne__(self, other):
24085 
    return not (self == other)
24086 
 
9242 kshitij.so 24087 
class getSnapdealItemDetails_args:
8739 vikram.rag 24088 
  """
24089 
  Attributes:
24090 
   - item_id
24091 
  """
24092 
 
24093 
  thrift_spec = (
24094 
    None, # 0
24095 
    (1, TType.I64, 'item_id', None, None, ), # 1
24096 
  )
24097 
 
24098 
  def __init__(self, item_id=None,):
24099 
    self.item_id = item_id
24100 
 
24101 
  def read(self, iprot):
24102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24104 
      return
24105 
    iprot.readStructBegin()
24106 
    while True:
24107 
      (fname, ftype, fid) = iprot.readFieldBegin()
24108 
      if ftype == TType.STOP:
24109 
        break
24110 
      if fid == 1:
24111 
        if ftype == TType.I64:
24112 
          self.item_id = iprot.readI64();
24113 
        else:
24114 
          iprot.skip(ftype)
24115 
      else:
24116 
        iprot.skip(ftype)
24117 
      iprot.readFieldEnd()
24118 
    iprot.readStructEnd()
24119 
 
24120 
  def write(self, oprot):
24121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24123 
      return
9242 kshitij.so 24124 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 24125 
    if self.item_id is not None:
24126 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
24127 
      oprot.writeI64(self.item_id)
24128 
      oprot.writeFieldEnd()
24129 
    oprot.writeFieldStop()
24130 
    oprot.writeStructEnd()
24131 
 
24132 
  def validate(self):
24133 
    return
24134 
 
24135 
 
24136 
  def __repr__(self):
24137 
    L = ['%s=%r' % (key, value)
24138 
      for key, value in self.__dict__.iteritems()]
24139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24140 
 
24141 
  def __eq__(self, other):
24142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24143 
 
24144 
  def __ne__(self, other):
24145 
    return not (self == other)
24146 
 
9242 kshitij.so 24147 
class getSnapdealItemDetails_result:
8739 vikram.rag 24148 
  """
24149 
  Attributes:
24150 
   - success
24151 
  """
24152 
 
24153 
  thrift_spec = (
9242 kshitij.so 24154 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 24155 
  )
24156 
 
24157 
  def __init__(self, success=None,):
24158 
    self.success = success
24159 
 
24160 
  def read(self, iprot):
24161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24163 
      return
24164 
    iprot.readStructBegin()
24165 
    while True:
24166 
      (fname, ftype, fid) = iprot.readFieldBegin()
24167 
      if ftype == TType.STOP:
24168 
        break
24169 
      if fid == 0:
24170 
        if ftype == TType.STRUCT:
9242 kshitij.so 24171 
          self.success = SnapdealItemDetails()
8739 vikram.rag 24172 
          self.success.read(iprot)
24173 
        else:
24174 
          iprot.skip(ftype)
24175 
      else:
24176 
        iprot.skip(ftype)
24177 
      iprot.readFieldEnd()
24178 
    iprot.readStructEnd()
24179 
 
24180 
  def write(self, oprot):
24181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24183 
      return
9242 kshitij.so 24184 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 24185 
    if self.success is not None:
24186 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24187 
      self.success.write(oprot)
24188 
      oprot.writeFieldEnd()
24189 
    oprot.writeFieldStop()
24190 
    oprot.writeStructEnd()
24191 
 
24192 
  def validate(self):
24193 
    return
24194 
 
24195 
 
24196 
  def __repr__(self):
24197 
    L = ['%s=%r' % (key, value)
24198 
      for key, value in self.__dict__.iteritems()]
24199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24200 
 
24201 
  def __eq__(self, other):
24202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24203 
 
24204 
  def __ne__(self, other):
24205 
    return not (self == other)
24206 
 
24207 
class getAllSnapdealItems_args:
24208 
 
24209 
  thrift_spec = (
24210 
  )
24211 
 
24212 
  def read(self, iprot):
24213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24215 
      return
24216 
    iprot.readStructBegin()
24217 
    while True:
24218 
      (fname, ftype, fid) = iprot.readFieldBegin()
24219 
      if ftype == TType.STOP:
24220 
        break
24221 
      else:
24222 
        iprot.skip(ftype)
24223 
      iprot.readFieldEnd()
24224 
    iprot.readStructEnd()
24225 
 
24226 
  def write(self, oprot):
24227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24229 
      return
24230 
    oprot.writeStructBegin('getAllSnapdealItems_args')
24231 
    oprot.writeFieldStop()
24232 
    oprot.writeStructEnd()
24233 
 
24234 
  def validate(self):
24235 
    return
24236 
 
24237 
 
24238 
  def __repr__(self):
24239 
    L = ['%s=%r' % (key, value)
24240 
      for key, value in self.__dict__.iteritems()]
24241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24242 
 
24243 
  def __eq__(self, other):
24244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24245 
 
24246 
  def __ne__(self, other):
24247 
    return not (self == other)
24248 
 
24249 
class getAllSnapdealItems_result:
24250 
  """
24251 
  Attributes:
24252 
   - success
24253 
  """
24254 
 
24255 
  thrift_spec = (
9242 kshitij.so 24256 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 24257 
  )
24258 
 
24259 
  def __init__(self, success=None,):
24260 
    self.success = success
24261 
 
24262 
  def read(self, iprot):
24263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24265 
      return
24266 
    iprot.readStructBegin()
24267 
    while True:
24268 
      (fname, ftype, fid) = iprot.readFieldBegin()
24269 
      if ftype == TType.STOP:
24270 
        break
24271 
      if fid == 0:
24272 
        if ftype == TType.LIST:
24273 
          self.success = []
9242 kshitij.so 24274 
          (_etype516, _size513) = iprot.readListBegin()
24275 
          for _i517 in xrange(_size513):
24276 
            _elem518 = SnapdealItemDetails()
24277 
            _elem518.read(iprot)
24278 
            self.success.append(_elem518)
24279 
          iprot.readListEnd()
24280 
        else:
24281 
          iprot.skip(ftype)
24282 
      else:
24283 
        iprot.skip(ftype)
24284 
      iprot.readFieldEnd()
24285 
    iprot.readStructEnd()
24286 
 
24287 
  def write(self, oprot):
24288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24290 
      return
24291 
    oprot.writeStructBegin('getAllSnapdealItems_result')
24292 
    if self.success is not None:
24293 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24294 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24295 
      for iter519 in self.success:
24296 
        iter519.write(oprot)
24297 
      oprot.writeListEnd()
24298 
      oprot.writeFieldEnd()
24299 
    oprot.writeFieldStop()
24300 
    oprot.writeStructEnd()
24301 
 
24302 
  def validate(self):
24303 
    return
24304 
 
24305 
 
24306 
  def __repr__(self):
24307 
    L = ['%s=%r' % (key, value)
24308 
      for key, value in self.__dict__.iteritems()]
24309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24310 
 
24311 
  def __eq__(self, other):
24312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24313 
 
24314 
  def __ne__(self, other):
24315 
    return not (self == other)
24316 
 
24317 
class getSnapdealItems_args:
24318 
  """
24319 
  Attributes:
24320 
   - offset
24321 
   - limit
24322 
  """
24323 
 
24324 
  thrift_spec = (
24325 
    None, # 0
24326 
    (1, TType.I64, 'offset', None, None, ), # 1
24327 
    (2, TType.I64, 'limit', None, None, ), # 2
24328 
  )
24329 
 
24330 
  def __init__(self, offset=None, limit=None,):
24331 
    self.offset = offset
24332 
    self.limit = limit
24333 
 
24334 
  def read(self, iprot):
24335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24337 
      return
24338 
    iprot.readStructBegin()
24339 
    while True:
24340 
      (fname, ftype, fid) = iprot.readFieldBegin()
24341 
      if ftype == TType.STOP:
24342 
        break
24343 
      if fid == 1:
24344 
        if ftype == TType.I64:
24345 
          self.offset = iprot.readI64();
24346 
        else:
24347 
          iprot.skip(ftype)
24348 
      elif fid == 2:
24349 
        if ftype == TType.I64:
24350 
          self.limit = iprot.readI64();
24351 
        else:
24352 
          iprot.skip(ftype)
24353 
      else:
24354 
        iprot.skip(ftype)
24355 
      iprot.readFieldEnd()
24356 
    iprot.readStructEnd()
24357 
 
24358 
  def write(self, oprot):
24359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24361 
      return
24362 
    oprot.writeStructBegin('getSnapdealItems_args')
24363 
    if self.offset is not None:
24364 
      oprot.writeFieldBegin('offset', TType.I64, 1)
24365 
      oprot.writeI64(self.offset)
24366 
      oprot.writeFieldEnd()
24367 
    if self.limit is not None:
24368 
      oprot.writeFieldBegin('limit', TType.I64, 2)
24369 
      oprot.writeI64(self.limit)
24370 
      oprot.writeFieldEnd()
24371 
    oprot.writeFieldStop()
24372 
    oprot.writeStructEnd()
24373 
 
24374 
  def validate(self):
24375 
    return
24376 
 
24377 
 
24378 
  def __repr__(self):
24379 
    L = ['%s=%r' % (key, value)
24380 
      for key, value in self.__dict__.iteritems()]
24381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24382 
 
24383 
  def __eq__(self, other):
24384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24385 
 
24386 
  def __ne__(self, other):
24387 
    return not (self == other)
24388 
 
24389 
class getSnapdealItems_result:
24390 
  """
24391 
  Attributes:
24392 
   - success
24393 
  """
24394 
 
24395 
  thrift_spec = (
24396 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
24397 
  )
24398 
 
24399 
  def __init__(self, success=None,):
24400 
    self.success = success
24401 
 
24402 
  def read(self, iprot):
24403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24405 
      return
24406 
    iprot.readStructBegin()
24407 
    while True:
24408 
      (fname, ftype, fid) = iprot.readFieldBegin()
24409 
      if ftype == TType.STOP:
24410 
        break
24411 
      if fid == 0:
24412 
        if ftype == TType.LIST:
24413 
          self.success = []
9155 kshitij.so 24414 
          (_etype523, _size520) = iprot.readListBegin()
24415 
          for _i524 in xrange(_size520):
9242 kshitij.so 24416 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 24417 
            _elem525.read(iprot)
24418 
            self.success.append(_elem525)
8739 vikram.rag 24419 
          iprot.readListEnd()
24420 
        else:
24421 
          iprot.skip(ftype)
24422 
      else:
24423 
        iprot.skip(ftype)
24424 
      iprot.readFieldEnd()
24425 
    iprot.readStructEnd()
24426 
 
24427 
  def write(self, oprot):
24428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24430 
      return
9242 kshitij.so 24431 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 24432 
    if self.success is not None:
24433 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24434 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 24435 
      for iter526 in self.success:
24436 
        iter526.write(oprot)
8739 vikram.rag 24437 
      oprot.writeListEnd()
24438 
      oprot.writeFieldEnd()
24439 
    oprot.writeFieldStop()
24440 
    oprot.writeStructEnd()
24441 
 
24442 
  def validate(self):
24443 
    return
24444 
 
24445 
 
24446 
  def __repr__(self):
24447 
    L = ['%s=%r' % (key, value)
24448 
      for key, value in self.__dict__.iteritems()]
24449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24450 
 
24451 
  def __eq__(self, other):
24452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24453 
 
24454 
  def __ne__(self, other):
24455 
    return not (self == other)
9242 kshitij.so 24456 
 
24457 
class searchSnapdealItems_args:
24458 
  """
24459 
  Attributes:
24460 
   - searchTerm
24461 
   - offset
24462 
   - limit
24463 
  """
24464 
 
24465 
  thrift_spec = (
24466 
    None, # 0
24467 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
24468 
    (2, TType.I64, 'offset', None, None, ), # 2
24469 
    (3, TType.I64, 'limit', None, None, ), # 3
24470 
  )
24471 
 
24472 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
24473 
    self.searchTerm = searchTerm
24474 
    self.offset = offset
24475 
    self.limit = limit
24476 
 
24477 
  def read(self, iprot):
24478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24480 
      return
24481 
    iprot.readStructBegin()
24482 
    while True:
24483 
      (fname, ftype, fid) = iprot.readFieldBegin()
24484 
      if ftype == TType.STOP:
24485 
        break
24486 
      if fid == 1:
24487 
        if ftype == TType.LIST:
24488 
          self.searchTerm = []
24489 
          (_etype530, _size527) = iprot.readListBegin()
24490 
          for _i531 in xrange(_size527):
24491 
            _elem532 = iprot.readString();
24492 
            self.searchTerm.append(_elem532)
24493 
          iprot.readListEnd()
24494 
        else:
24495 
          iprot.skip(ftype)
24496 
      elif fid == 2:
24497 
        if ftype == TType.I64:
24498 
          self.offset = iprot.readI64();
24499 
        else:
24500 
          iprot.skip(ftype)
24501 
      elif fid == 3:
24502 
        if ftype == TType.I64:
24503 
          self.limit = iprot.readI64();
24504 
        else:
24505 
          iprot.skip(ftype)
24506 
      else:
24507 
        iprot.skip(ftype)
24508 
      iprot.readFieldEnd()
24509 
    iprot.readStructEnd()
24510 
 
24511 
  def write(self, oprot):
24512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24514 
      return
24515 
    oprot.writeStructBegin('searchSnapdealItems_args')
24516 
    if self.searchTerm is not None:
24517 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
24518 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
24519 
      for iter533 in self.searchTerm:
24520 
        oprot.writeString(iter533)
24521 
      oprot.writeListEnd()
24522 
      oprot.writeFieldEnd()
24523 
    if self.offset is not None:
24524 
      oprot.writeFieldBegin('offset', TType.I64, 2)
24525 
      oprot.writeI64(self.offset)
24526 
      oprot.writeFieldEnd()
24527 
    if self.limit is not None:
24528 
      oprot.writeFieldBegin('limit', TType.I64, 3)
24529 
      oprot.writeI64(self.limit)
24530 
      oprot.writeFieldEnd()
24531 
    oprot.writeFieldStop()
24532 
    oprot.writeStructEnd()
24533 
 
24534 
  def validate(self):
24535 
    return
24536 
 
24537 
 
24538 
  def __repr__(self):
24539 
    L = ['%s=%r' % (key, value)
24540 
      for key, value in self.__dict__.iteritems()]
24541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24542 
 
24543 
  def __eq__(self, other):
24544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24545 
 
24546 
  def __ne__(self, other):
24547 
    return not (self == other)
24548 
 
24549 
class searchSnapdealItems_result:
24550 
  """
24551 
  Attributes:
24552 
   - success
24553 
  """
24554 
 
24555 
  thrift_spec = (
24556 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
24557 
  )
24558 
 
24559 
  def __init__(self, success=None,):
24560 
    self.success = success
24561 
 
24562 
  def read(self, iprot):
24563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24565 
      return
24566 
    iprot.readStructBegin()
24567 
    while True:
24568 
      (fname, ftype, fid) = iprot.readFieldBegin()
24569 
      if ftype == TType.STOP:
24570 
        break
24571 
      if fid == 0:
24572 
        if ftype == TType.LIST:
24573 
          self.success = []
24574 
          (_etype537, _size534) = iprot.readListBegin()
24575 
          for _i538 in xrange(_size534):
24576 
            _elem539 = SnapdealItemDetails()
24577 
            _elem539.read(iprot)
24578 
            self.success.append(_elem539)
24579 
          iprot.readListEnd()
24580 
        else:
24581 
          iprot.skip(ftype)
24582 
      else:
24583 
        iprot.skip(ftype)
24584 
      iprot.readFieldEnd()
24585 
    iprot.readStructEnd()
24586 
 
24587 
  def write(self, oprot):
24588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24590 
      return
24591 
    oprot.writeStructBegin('searchSnapdealItems_result')
24592 
    if self.success is not None:
24593 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24594 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24595 
      for iter540 in self.success:
24596 
        iter540.write(oprot)
24597 
      oprot.writeListEnd()
24598 
      oprot.writeFieldEnd()
24599 
    oprot.writeFieldStop()
24600 
    oprot.writeStructEnd()
24601 
 
24602 
  def validate(self):
24603 
    return
24604 
 
24605 
 
24606 
  def __repr__(self):
24607 
    L = ['%s=%r' % (key, value)
24608 
      for key, value in self.__dict__.iteritems()]
24609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24610 
 
24611 
  def __eq__(self, other):
24612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24613 
 
24614 
  def __ne__(self, other):
24615 
    return not (self == other)
24616 
 
24617 
class getCountForSnapdealItems_args:
24618 
 
24619 
  thrift_spec = (
24620 
  )
24621 
 
24622 
  def read(self, iprot):
24623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24625 
      return
24626 
    iprot.readStructBegin()
24627 
    while True:
24628 
      (fname, ftype, fid) = iprot.readFieldBegin()
24629 
      if ftype == TType.STOP:
24630 
        break
24631 
      else:
24632 
        iprot.skip(ftype)
24633 
      iprot.readFieldEnd()
24634 
    iprot.readStructEnd()
24635 
 
24636 
  def write(self, oprot):
24637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24639 
      return
24640 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
24641 
    oprot.writeFieldStop()
24642 
    oprot.writeStructEnd()
24643 
 
24644 
  def validate(self):
24645 
    return
24646 
 
24647 
 
24648 
  def __repr__(self):
24649 
    L = ['%s=%r' % (key, value)
24650 
      for key, value in self.__dict__.iteritems()]
24651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24652 
 
24653 
  def __eq__(self, other):
24654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24655 
 
24656 
  def __ne__(self, other):
24657 
    return not (self == other)
24658 
 
24659 
class getCountForSnapdealItems_result:
24660 
  """
24661 
  Attributes:
24662 
   - success
24663 
  """
24664 
 
24665 
  thrift_spec = (
24666 
    (0, TType.I64, 'success', None, None, ), # 0
24667 
  )
24668 
 
24669 
  def __init__(self, success=None,):
24670 
    self.success = success
24671 
 
24672 
  def read(self, iprot):
24673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24675 
      return
24676 
    iprot.readStructBegin()
24677 
    while True:
24678 
      (fname, ftype, fid) = iprot.readFieldBegin()
24679 
      if ftype == TType.STOP:
24680 
        break
24681 
      if fid == 0:
24682 
        if ftype == TType.I64:
24683 
          self.success = iprot.readI64();
24684 
        else:
24685 
          iprot.skip(ftype)
24686 
      else:
24687 
        iprot.skip(ftype)
24688 
      iprot.readFieldEnd()
24689 
    iprot.readStructEnd()
24690 
 
24691 
  def write(self, oprot):
24692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24694 
      return
24695 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
24696 
    if self.success is not None:
24697 
      oprot.writeFieldBegin('success', TType.I64, 0)
24698 
      oprot.writeI64(self.success)
24699 
      oprot.writeFieldEnd()
24700 
    oprot.writeFieldStop()
24701 
    oprot.writeStructEnd()
24702 
 
24703 
  def validate(self):
24704 
    return
24705 
 
24706 
 
24707 
  def __repr__(self):
24708 
    L = ['%s=%r' % (key, value)
24709 
      for key, value in self.__dict__.iteritems()]
24710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24711 
 
24712 
  def __eq__(self, other):
24713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24714 
 
24715 
  def __ne__(self, other):
24716 
    return not (self == other)
24717 
 
24718 
class getSnapdealSearchResultCount_args:
24719 
  """
24720 
  Attributes:
24721 
   - searchTerm
24722 
  """
24723 
 
24724 
  thrift_spec = (
24725 
    None, # 0
24726 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
24727 
  )
24728 
 
24729 
  def __init__(self, searchTerm=None,):
24730 
    self.searchTerm = searchTerm
24731 
 
24732 
  def read(self, iprot):
24733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24735 
      return
24736 
    iprot.readStructBegin()
24737 
    while True:
24738 
      (fname, ftype, fid) = iprot.readFieldBegin()
24739 
      if ftype == TType.STOP:
24740 
        break
24741 
      if fid == 1:
24742 
        if ftype == TType.LIST:
24743 
          self.searchTerm = []
24744 
          (_etype544, _size541) = iprot.readListBegin()
24745 
          for _i545 in xrange(_size541):
24746 
            _elem546 = iprot.readString();
24747 
            self.searchTerm.append(_elem546)
24748 
          iprot.readListEnd()
24749 
        else:
24750 
          iprot.skip(ftype)
24751 
      else:
24752 
        iprot.skip(ftype)
24753 
      iprot.readFieldEnd()
24754 
    iprot.readStructEnd()
24755 
 
24756 
  def write(self, oprot):
24757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24759 
      return
24760 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
24761 
    if self.searchTerm is not None:
24762 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
24763 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
24764 
      for iter547 in self.searchTerm:
24765 
        oprot.writeString(iter547)
24766 
      oprot.writeListEnd()
24767 
      oprot.writeFieldEnd()
24768 
    oprot.writeFieldStop()
24769 
    oprot.writeStructEnd()
24770 
 
24771 
  def validate(self):
24772 
    return
24773 
 
24774 
 
24775 
  def __repr__(self):
24776 
    L = ['%s=%r' % (key, value)
24777 
      for key, value in self.__dict__.iteritems()]
24778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24779 
 
24780 
  def __eq__(self, other):
24781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24782 
 
24783 
  def __ne__(self, other):
24784 
    return not (self == other)
24785 
 
24786 
class getSnapdealSearchResultCount_result:
24787 
  """
24788 
  Attributes:
24789 
   - success
24790 
  """
24791 
 
24792 
  thrift_spec = (
24793 
    (0, TType.I64, 'success', None, None, ), # 0
24794 
  )
24795 
 
24796 
  def __init__(self, success=None,):
24797 
    self.success = success
24798 
 
24799 
  def read(self, iprot):
24800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24802 
      return
24803 
    iprot.readStructBegin()
24804 
    while True:
24805 
      (fname, ftype, fid) = iprot.readFieldBegin()
24806 
      if ftype == TType.STOP:
24807 
        break
24808 
      if fid == 0:
24809 
        if ftype == TType.I64:
24810 
          self.success = iprot.readI64();
24811 
        else:
24812 
          iprot.skip(ftype)
24813 
      else:
24814 
        iprot.skip(ftype)
24815 
      iprot.readFieldEnd()
24816 
    iprot.readStructEnd()
24817 
 
24818 
  def write(self, oprot):
24819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24821 
      return
24822 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
24823 
    if self.success is not None:
24824 
      oprot.writeFieldBegin('success', TType.I64, 0)
24825 
      oprot.writeI64(self.success)
24826 
      oprot.writeFieldEnd()
24827 
    oprot.writeFieldStop()
24828 
    oprot.writeStructEnd()
24829 
 
24830 
  def validate(self):
24831 
    return
24832 
 
24833 
 
24834 
  def __repr__(self):
24835 
    L = ['%s=%r' % (key, value)
24836 
      for key, value in self.__dict__.iteritems()]
24837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24838 
 
24839 
  def __eq__(self, other):
24840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24841 
 
24842 
  def __ne__(self, other):
24843 
    return not (self == other)
9299 kshitij.so 24844 
 
24845 
class getPrefferedInsurerForItem_args:
24846 
  """
24847 
  Attributes:
24848 
   - itemId
24849 
   - insurerType
24850 
  """
24851 
 
24852 
  thrift_spec = (
24853 
    None, # 0
24854 
    (1, TType.I64, 'itemId', None, None, ), # 1
24855 
    (2, TType.I32, 'insurerType', None, None, ), # 2
24856 
  )
24857 
 
24858 
  def __init__(self, itemId=None, insurerType=None,):
24859 
    self.itemId = itemId
24860 
    self.insurerType = insurerType
24861 
 
24862 
  def read(self, iprot):
24863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24865 
      return
24866 
    iprot.readStructBegin()
24867 
    while True:
24868 
      (fname, ftype, fid) = iprot.readFieldBegin()
24869 
      if ftype == TType.STOP:
24870 
        break
24871 
      if fid == 1:
24872 
        if ftype == TType.I64:
24873 
          self.itemId = iprot.readI64();
24874 
        else:
24875 
          iprot.skip(ftype)
24876 
      elif fid == 2:
24877 
        if ftype == TType.I32:
24878 
          self.insurerType = iprot.readI32();
24879 
        else:
24880 
          iprot.skip(ftype)
24881 
      else:
24882 
        iprot.skip(ftype)
24883 
      iprot.readFieldEnd()
24884 
    iprot.readStructEnd()
24885 
 
24886 
  def write(self, oprot):
24887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24889 
      return
24890 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
24891 
    if self.itemId is not None:
24892 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24893 
      oprot.writeI64(self.itemId)
24894 
      oprot.writeFieldEnd()
24895 
    if self.insurerType is not None:
24896 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
24897 
      oprot.writeI32(self.insurerType)
24898 
      oprot.writeFieldEnd()
24899 
    oprot.writeFieldStop()
24900 
    oprot.writeStructEnd()
24901 
 
24902 
  def validate(self):
24903 
    return
24904 
 
24905 
 
24906 
  def __repr__(self):
24907 
    L = ['%s=%r' % (key, value)
24908 
      for key, value in self.__dict__.iteritems()]
24909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24910 
 
24911 
  def __eq__(self, other):
24912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24913 
 
24914 
  def __ne__(self, other):
24915 
    return not (self == other)
24916 
 
24917 
class getPrefferedInsurerForItem_result:
24918 
  """
24919 
  Attributes:
24920 
   - success
24921 
  """
24922 
 
24923 
  thrift_spec = (
24924 
    (0, TType.I64, 'success', None, None, ), # 0
24925 
  )
24926 
 
24927 
  def __init__(self, success=None,):
24928 
    self.success = success
24929 
 
24930 
  def read(self, iprot):
24931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24933 
      return
24934 
    iprot.readStructBegin()
24935 
    while True:
24936 
      (fname, ftype, fid) = iprot.readFieldBegin()
24937 
      if ftype == TType.STOP:
24938 
        break
24939 
      if fid == 0:
24940 
        if ftype == TType.I64:
24941 
          self.success = iprot.readI64();
24942 
        else:
24943 
          iprot.skip(ftype)
24944 
      else:
24945 
        iprot.skip(ftype)
24946 
      iprot.readFieldEnd()
24947 
    iprot.readStructEnd()
24948 
 
24949 
  def write(self, oprot):
24950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24952 
      return
24953 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
24954 
    if self.success is not None:
24955 
      oprot.writeFieldBegin('success', TType.I64, 0)
24956 
      oprot.writeI64(self.success)
24957 
      oprot.writeFieldEnd()
24958 
    oprot.writeFieldStop()
24959 
    oprot.writeStructEnd()
24960 
 
24961 
  def validate(self):
24962 
    return
24963 
 
24964 
 
24965 
  def __repr__(self):
24966 
    L = ['%s=%r' % (key, value)
24967 
      for key, value in self.__dict__.iteritems()]
24968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24969 
 
24970 
  def __eq__(self, other):
24971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24972 
 
24973 
  def __ne__(self, other):
24974 
    return not (self == other)
9456 vikram.rag 24975 
 
24976 
class getSnapdealItembySkuAtSnapdeal_args:
24977 
  """
24978 
  Attributes:
24979 
   - skuAtSnapdeal
24980 
  """
24981 
 
24982 
  thrift_spec = None
24983 
  def __init__(self, skuAtSnapdeal=None,):
24984 
    self.skuAtSnapdeal = skuAtSnapdeal
24985 
 
24986 
  def read(self, iprot):
24987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24989 
      return
24990 
    iprot.readStructBegin()
24991 
    while True:
24992 
      (fname, ftype, fid) = iprot.readFieldBegin()
24993 
      if ftype == TType.STOP:
24994 
        break
24995 
      if fid == -1:
24996 
        if ftype == TType.STRING:
24997 
          self.skuAtSnapdeal = iprot.readString();
24998 
        else:
24999 
          iprot.skip(ftype)
25000 
      else:
25001 
        iprot.skip(ftype)
25002 
      iprot.readFieldEnd()
25003 
    iprot.readStructEnd()
25004 
 
25005 
  def write(self, oprot):
25006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25008 
      return
25009 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
25010 
    if self.skuAtSnapdeal is not None:
25011 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
25012 
      oprot.writeString(self.skuAtSnapdeal)
25013 
      oprot.writeFieldEnd()
25014 
    oprot.writeFieldStop()
25015 
    oprot.writeStructEnd()
25016 
 
25017 
  def validate(self):
25018 
    return
25019 
 
25020 
 
25021 
  def __repr__(self):
25022 
    L = ['%s=%r' % (key, value)
25023 
      for key, value in self.__dict__.iteritems()]
25024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25025 
 
25026 
  def __eq__(self, other):
25027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25028 
 
25029 
  def __ne__(self, other):
25030 
    return not (self == other)
25031 
 
25032 
class getSnapdealItembySkuAtSnapdeal_result:
25033 
  """
25034 
  Attributes:
25035 
   - success
25036 
  """
25037 
 
25038 
  thrift_spec = (
25039 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
25040 
  )
25041 
 
25042 
  def __init__(self, success=None,):
25043 
    self.success = success
25044 
 
25045 
  def read(self, iprot):
25046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25048 
      return
25049 
    iprot.readStructBegin()
25050 
    while True:
25051 
      (fname, ftype, fid) = iprot.readFieldBegin()
25052 
      if ftype == TType.STOP:
25053 
        break
25054 
      if fid == 0:
25055 
        if ftype == TType.STRUCT:
25056 
          self.success = SnapdealItem()
25057 
          self.success.read(iprot)
25058 
        else:
25059 
          iprot.skip(ftype)
25060 
      else:
25061 
        iprot.skip(ftype)
25062 
      iprot.readFieldEnd()
25063 
    iprot.readStructEnd()
25064 
 
25065 
  def write(self, oprot):
25066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25068 
      return
25069 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
25070 
    if self.success is not None:
25071 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25072 
      self.success.write(oprot)
25073 
      oprot.writeFieldEnd()
25074 
    oprot.writeFieldStop()
25075 
    oprot.writeStructEnd()
25076 
 
25077 
  def validate(self):
25078 
    return
25079 
 
25080 
 
25081 
  def __repr__(self):
25082 
    L = ['%s=%r' % (key, value)
25083 
      for key, value in self.__dict__.iteritems()]
25084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25085 
 
25086 
  def __eq__(self, other):
25087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25088 
 
25089 
  def __ne__(self, other):
25090 
    return not (self == other)
9621 manish.sha 25091 
 
25092 
class getProductFeedSubmit_args:
25093 
  """
25094 
  Attributes:
25095 
   - catalogItemId
25096 
  """
25097 
 
25098 
  thrift_spec = (
25099 
    None, # 0
25100 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
25101 
  )
25102 
 
25103 
  def __init__(self, catalogItemId=None,):
25104 
    self.catalogItemId = catalogItemId
25105 
 
25106 
  def read(self, iprot):
25107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25109 
      return
25110 
    iprot.readStructBegin()
25111 
    while True:
25112 
      (fname, ftype, fid) = iprot.readFieldBegin()
25113 
      if ftype == TType.STOP:
25114 
        break
25115 
      if fid == 1:
25116 
        if ftype == TType.I64:
25117 
          self.catalogItemId = iprot.readI64();
25118 
        else:
25119 
          iprot.skip(ftype)
25120 
      else:
25121 
        iprot.skip(ftype)
25122 
      iprot.readFieldEnd()
25123 
    iprot.readStructEnd()
25124 
 
25125 
  def write(self, oprot):
25126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25128 
      return
25129 
    oprot.writeStructBegin('getProductFeedSubmit_args')
25130 
    if self.catalogItemId is not None:
25131 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
25132 
      oprot.writeI64(self.catalogItemId)
25133 
      oprot.writeFieldEnd()
25134 
    oprot.writeFieldStop()
25135 
    oprot.writeStructEnd()
25136 
 
25137 
  def validate(self):
25138 
    return
25139 
 
25140 
 
25141 
  def __repr__(self):
25142 
    L = ['%s=%r' % (key, value)
25143 
      for key, value in self.__dict__.iteritems()]
25144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25145 
 
25146 
  def __eq__(self, other):
25147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25148 
 
25149 
  def __ne__(self, other):
25150 
    return not (self == other)
25151 
 
25152 
class getProductFeedSubmit_result:
25153 
  """
25154 
  Attributes:
25155 
   - success
25156 
   - cex
25157 
  """
25158 
 
25159 
  thrift_spec = (
25160 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
25161 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25162 
  )
25163 
 
25164 
  def __init__(self, success=None, cex=None,):
25165 
    self.success = success
25166 
    self.cex = cex
25167 
 
25168 
  def read(self, iprot):
25169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25171 
      return
25172 
    iprot.readStructBegin()
25173 
    while True:
25174 
      (fname, ftype, fid) = iprot.readFieldBegin()
25175 
      if ftype == TType.STOP:
25176 
        break
25177 
      if fid == 0:
25178 
        if ftype == TType.STRUCT:
25179 
          self.success = ProductFeedSubmit()
25180 
          self.success.read(iprot)
25181 
        else:
25182 
          iprot.skip(ftype)
25183 
      elif fid == 1:
25184 
        if ftype == TType.STRUCT:
25185 
          self.cex = CatalogServiceException()
25186 
          self.cex.read(iprot)
25187 
        else:
25188 
          iprot.skip(ftype)
25189 
      else:
25190 
        iprot.skip(ftype)
25191 
      iprot.readFieldEnd()
25192 
    iprot.readStructEnd()
25193 
 
25194 
  def write(self, oprot):
25195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25197 
      return
25198 
    oprot.writeStructBegin('getProductFeedSubmit_result')
25199 
    if self.success is not None:
25200 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25201 
      self.success.write(oprot)
25202 
      oprot.writeFieldEnd()
25203 
    if self.cex is not None:
25204 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25205 
      self.cex.write(oprot)
25206 
      oprot.writeFieldEnd()
25207 
    oprot.writeFieldStop()
25208 
    oprot.writeStructEnd()
25209 
 
25210 
  def validate(self):
25211 
    return
25212 
 
25213 
 
25214 
  def __repr__(self):
25215 
    L = ['%s=%r' % (key, value)
25216 
      for key, value in self.__dict__.iteritems()]
25217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25218 
 
25219 
  def __eq__(self, other):
25220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25221 
 
25222 
  def __ne__(self, other):
25223 
    return not (self == other)
25224 
 
25225 
class addProductFeedSubmit_args:
25226 
  """
25227 
  Attributes:
25228 
   - productFeedSubmit
25229 
  """
25230 
 
25231 
  thrift_spec = (
25232 
    None, # 0
25233 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
25234 
  )
25235 
 
25236 
  def __init__(self, productFeedSubmit=None,):
25237 
    self.productFeedSubmit = productFeedSubmit
25238 
 
25239 
  def read(self, iprot):
25240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25242 
      return
25243 
    iprot.readStructBegin()
25244 
    while True:
25245 
      (fname, ftype, fid) = iprot.readFieldBegin()
25246 
      if ftype == TType.STOP:
25247 
        break
25248 
      if fid == 1:
25249 
        if ftype == TType.STRUCT:
25250 
          self.productFeedSubmit = ProductFeedSubmit()
25251 
          self.productFeedSubmit.read(iprot)
25252 
        else:
25253 
          iprot.skip(ftype)
25254 
      else:
25255 
        iprot.skip(ftype)
25256 
      iprot.readFieldEnd()
25257 
    iprot.readStructEnd()
25258 
 
25259 
  def write(self, oprot):
25260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25262 
      return
25263 
    oprot.writeStructBegin('addProductFeedSubmit_args')
25264 
    if self.productFeedSubmit is not None:
25265 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
25266 
      self.productFeedSubmit.write(oprot)
25267 
      oprot.writeFieldEnd()
25268 
    oprot.writeFieldStop()
25269 
    oprot.writeStructEnd()
25270 
 
25271 
  def validate(self):
25272 
    return
25273 
 
25274 
 
25275 
  def __repr__(self):
25276 
    L = ['%s=%r' % (key, value)
25277 
      for key, value in self.__dict__.iteritems()]
25278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25279 
 
25280 
  def __eq__(self, other):
25281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25282 
 
25283 
  def __ne__(self, other):
25284 
    return not (self == other)
25285 
 
25286 
class addProductFeedSubmit_result:
25287 
  """
25288 
  Attributes:
25289 
   - success
25290 
   - cex
25291 
  """
25292 
 
25293 
  thrift_spec = (
25294 
    (0, TType.BOOL, 'success', None, None, ), # 0
25295 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25296 
  )
25297 
 
25298 
  def __init__(self, success=None, cex=None,):
25299 
    self.success = success
25300 
    self.cex = cex
25301 
 
25302 
  def read(self, iprot):
25303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25305 
      return
25306 
    iprot.readStructBegin()
25307 
    while True:
25308 
      (fname, ftype, fid) = iprot.readFieldBegin()
25309 
      if ftype == TType.STOP:
25310 
        break
25311 
      if fid == 0:
25312 
        if ftype == TType.BOOL:
25313 
          self.success = iprot.readBool();
25314 
        else:
25315 
          iprot.skip(ftype)
25316 
      elif fid == 1:
25317 
        if ftype == TType.STRUCT:
25318 
          self.cex = CatalogServiceException()
25319 
          self.cex.read(iprot)
25320 
        else:
25321 
          iprot.skip(ftype)
25322 
      else:
25323 
        iprot.skip(ftype)
25324 
      iprot.readFieldEnd()
25325 
    iprot.readStructEnd()
25326 
 
25327 
  def write(self, oprot):
25328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25330 
      return
25331 
    oprot.writeStructBegin('addProductFeedSubmit_result')
25332 
    if self.success is not None:
25333 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25334 
      oprot.writeBool(self.success)
25335 
      oprot.writeFieldEnd()
25336 
    if self.cex is not None:
25337 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25338 
      self.cex.write(oprot)
25339 
      oprot.writeFieldEnd()
25340 
    oprot.writeFieldStop()
25341 
    oprot.writeStructEnd()
25342 
 
25343 
  def validate(self):
25344 
    return
25345 
 
25346 
 
25347 
  def __repr__(self):
25348 
    L = ['%s=%r' % (key, value)
25349 
      for key, value in self.__dict__.iteritems()]
25350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25351 
 
25352 
  def __eq__(self, other):
25353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25354 
 
25355 
  def __ne__(self, other):
25356 
    return not (self == other)
25357 
 
25358 
class updateProductFeedSubmit_args:
25359 
  """
25360 
  Attributes:
25361 
   - productFeedSubmit
25362 
  """
25363 
 
25364 
  thrift_spec = (
25365 
    None, # 0
25366 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
25367 
  )
25368 
 
25369 
  def __init__(self, productFeedSubmit=None,):
25370 
    self.productFeedSubmit = productFeedSubmit
25371 
 
25372 
  def read(self, iprot):
25373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25375 
      return
25376 
    iprot.readStructBegin()
25377 
    while True:
25378 
      (fname, ftype, fid) = iprot.readFieldBegin()
25379 
      if ftype == TType.STOP:
25380 
        break
25381 
      if fid == 1:
25382 
        if ftype == TType.STRUCT:
25383 
          self.productFeedSubmit = ProductFeedSubmit()
25384 
          self.productFeedSubmit.read(iprot)
25385 
        else:
25386 
          iprot.skip(ftype)
25387 
      else:
25388 
        iprot.skip(ftype)
25389 
      iprot.readFieldEnd()
25390 
    iprot.readStructEnd()
25391 
 
25392 
  def write(self, oprot):
25393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25395 
      return
25396 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
25397 
    if self.productFeedSubmit is not None:
25398 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
25399 
      self.productFeedSubmit.write(oprot)
25400 
      oprot.writeFieldEnd()
25401 
    oprot.writeFieldStop()
25402 
    oprot.writeStructEnd()
25403 
 
25404 
  def validate(self):
25405 
    return
25406 
 
25407 
 
25408 
  def __repr__(self):
25409 
    L = ['%s=%r' % (key, value)
25410 
      for key, value in self.__dict__.iteritems()]
25411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25412 
 
25413 
  def __eq__(self, other):
25414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25415 
 
25416 
  def __ne__(self, other):
25417 
    return not (self == other)
25418 
 
25419 
class updateProductFeedSubmit_result:
25420 
  """
25421 
  Attributes:
25422 
   - success
25423 
   - cex
25424 
  """
25425 
 
25426 
  thrift_spec = (
25427 
    (0, TType.BOOL, 'success', None, None, ), # 0
25428 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25429 
  )
25430 
 
25431 
  def __init__(self, success=None, cex=None,):
25432 
    self.success = success
25433 
    self.cex = cex
25434 
 
25435 
  def read(self, iprot):
25436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25438 
      return
25439 
    iprot.readStructBegin()
25440 
    while True:
25441 
      (fname, ftype, fid) = iprot.readFieldBegin()
25442 
      if ftype == TType.STOP:
25443 
        break
25444 
      if fid == 0:
25445 
        if ftype == TType.BOOL:
25446 
          self.success = iprot.readBool();
25447 
        else:
25448 
          iprot.skip(ftype)
25449 
      elif fid == 1:
25450 
        if ftype == TType.STRUCT:
25451 
          self.cex = CatalogServiceException()
25452 
          self.cex.read(iprot)
25453 
        else:
25454 
          iprot.skip(ftype)
25455 
      else:
25456 
        iprot.skip(ftype)
25457 
      iprot.readFieldEnd()
25458 
    iprot.readStructEnd()
25459 
 
25460 
  def write(self, oprot):
25461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25463 
      return
25464 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
25465 
    if self.success is not None:
25466 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25467 
      oprot.writeBool(self.success)
25468 
      oprot.writeFieldEnd()
25469 
    if self.cex is not None:
25470 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25471 
      self.cex.write(oprot)
25472 
      oprot.writeFieldEnd()
25473 
    oprot.writeFieldStop()
25474 
    oprot.writeStructEnd()
25475 
 
25476 
  def validate(self):
25477 
    return
25478 
 
25479 
 
25480 
  def __repr__(self):
25481 
    L = ['%s=%r' % (key, value)
25482 
      for key, value in self.__dict__.iteritems()]
25483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25484 
 
25485 
  def __eq__(self, other):
25486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25487 
 
25488 
  def __ne__(self, other):
25489 
    return not (self == other)
25490 
 
25491 
class deleteProductFeedSubmit_args:
25492 
  """
25493 
  Attributes:
25494 
   - catalogItemId
25495 
  """
25496 
 
25497 
  thrift_spec = (
25498 
    None, # 0
25499 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
25500 
  )
25501 
 
25502 
  def __init__(self, catalogItemId=None,):
25503 
    self.catalogItemId = catalogItemId
25504 
 
25505 
  def read(self, iprot):
25506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25508 
      return
25509 
    iprot.readStructBegin()
25510 
    while True:
25511 
      (fname, ftype, fid) = iprot.readFieldBegin()
25512 
      if ftype == TType.STOP:
25513 
        break
25514 
      if fid == 1:
25515 
        if ftype == TType.I64:
25516 
          self.catalogItemId = iprot.readI64();
25517 
        else:
25518 
          iprot.skip(ftype)
25519 
      else:
25520 
        iprot.skip(ftype)
25521 
      iprot.readFieldEnd()
25522 
    iprot.readStructEnd()
25523 
 
25524 
  def write(self, oprot):
25525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25527 
      return
25528 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
25529 
    if self.catalogItemId is not None:
25530 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
25531 
      oprot.writeI64(self.catalogItemId)
25532 
      oprot.writeFieldEnd()
25533 
    oprot.writeFieldStop()
25534 
    oprot.writeStructEnd()
25535 
 
25536 
  def validate(self):
25537 
    return
25538 
 
25539 
 
25540 
  def __repr__(self):
25541 
    L = ['%s=%r' % (key, value)
25542 
      for key, value in self.__dict__.iteritems()]
25543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25544 
 
25545 
  def __eq__(self, other):
25546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25547 
 
25548 
  def __ne__(self, other):
25549 
    return not (self == other)
25550 
 
25551 
class deleteProductFeedSubmit_result:
25552 
  """
25553 
  Attributes:
25554 
   - success
25555 
   - cex
25556 
  """
25557 
 
25558 
  thrift_spec = (
25559 
    (0, TType.BOOL, 'success', None, None, ), # 0
25560 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25561 
  )
25562 
 
25563 
  def __init__(self, success=None, cex=None,):
25564 
    self.success = success
25565 
    self.cex = cex
25566 
 
25567 
  def read(self, iprot):
25568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25570 
      return
25571 
    iprot.readStructBegin()
25572 
    while True:
25573 
      (fname, ftype, fid) = iprot.readFieldBegin()
25574 
      if ftype == TType.STOP:
25575 
        break
25576 
      if fid == 0:
25577 
        if ftype == TType.BOOL:
25578 
          self.success = iprot.readBool();
25579 
        else:
25580 
          iprot.skip(ftype)
25581 
      elif fid == 1:
25582 
        if ftype == TType.STRUCT:
25583 
          self.cex = CatalogServiceException()
25584 
          self.cex.read(iprot)
25585 
        else:
25586 
          iprot.skip(ftype)
25587 
      else:
25588 
        iprot.skip(ftype)
25589 
      iprot.readFieldEnd()
25590 
    iprot.readStructEnd()
25591 
 
25592 
  def write(self, oprot):
25593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25595 
      return
25596 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
25597 
    if self.success is not None:
25598 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25599 
      oprot.writeBool(self.success)
25600 
      oprot.writeFieldEnd()
25601 
    if self.cex is not None:
25602 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25603 
      self.cex.write(oprot)
25604 
      oprot.writeFieldEnd()
25605 
    oprot.writeFieldStop()
25606 
    oprot.writeStructEnd()
25607 
 
25608 
  def validate(self):
25609 
    return
25610 
 
25611 
 
25612 
  def __repr__(self):
25613 
    L = ['%s=%r' % (key, value)
25614 
      for key, value in self.__dict__.iteritems()]
25615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25616 
 
25617 
  def __eq__(self, other):
25618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25619 
 
25620 
  def __ne__(self, other):
25621 
    return not (self == other)
25622 
 
25623 
class getAllProductFeedSubmit_args:
25624 
 
25625 
  thrift_spec = (
25626 
  )
25627 
 
25628 
  def read(self, iprot):
25629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25631 
      return
25632 
    iprot.readStructBegin()
25633 
    while True:
25634 
      (fname, ftype, fid) = iprot.readFieldBegin()
25635 
      if ftype == TType.STOP:
25636 
        break
25637 
      else:
25638 
        iprot.skip(ftype)
25639 
      iprot.readFieldEnd()
25640 
    iprot.readStructEnd()
25641 
 
25642 
  def write(self, oprot):
25643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25645 
      return
25646 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
25647 
    oprot.writeFieldStop()
25648 
    oprot.writeStructEnd()
25649 
 
25650 
  def validate(self):
25651 
    return
25652 
 
25653 
 
25654 
  def __repr__(self):
25655 
    L = ['%s=%r' % (key, value)
25656 
      for key, value in self.__dict__.iteritems()]
25657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25658 
 
25659 
  def __eq__(self, other):
25660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25661 
 
25662 
  def __ne__(self, other):
25663 
    return not (self == other)
25664 
 
25665 
class getAllProductFeedSubmit_result:
25666 
  """
25667 
  Attributes:
25668 
   - success
25669 
   - cex
25670 
  """
25671 
 
25672 
  thrift_spec = (
25673 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
25674 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25675 
  )
25676 
 
25677 
  def __init__(self, success=None, cex=None,):
25678 
    self.success = success
25679 
    self.cex = cex
25680 
 
25681 
  def read(self, iprot):
25682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25684 
      return
25685 
    iprot.readStructBegin()
25686 
    while True:
25687 
      (fname, ftype, fid) = iprot.readFieldBegin()
25688 
      if ftype == TType.STOP:
25689 
        break
25690 
      if fid == 0:
25691 
        if ftype == TType.LIST:
25692 
          self.success = []
25693 
          (_etype551, _size548) = iprot.readListBegin()
25694 
          for _i552 in xrange(_size548):
25695 
            _elem553 = ProductFeedSubmit()
25696 
            _elem553.read(iprot)
25697 
            self.success.append(_elem553)
25698 
          iprot.readListEnd()
25699 
        else:
25700 
          iprot.skip(ftype)
25701 
      elif fid == 1:
25702 
        if ftype == TType.STRUCT:
25703 
          self.cex = CatalogServiceException()
25704 
          self.cex.read(iprot)
25705 
        else:
25706 
          iprot.skip(ftype)
25707 
      else:
25708 
        iprot.skip(ftype)
25709 
      iprot.readFieldEnd()
25710 
    iprot.readStructEnd()
25711 
 
25712 
  def write(self, oprot):
25713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25715 
      return
25716 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
25717 
    if self.success is not None:
25718 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25719 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25720 
      for iter554 in self.success:
25721 
        iter554.write(oprot)
25722 
      oprot.writeListEnd()
25723 
      oprot.writeFieldEnd()
25724 
    if self.cex is not None:
25725 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25726 
      self.cex.write(oprot)
25727 
      oprot.writeFieldEnd()
25728 
    oprot.writeFieldStop()
25729 
    oprot.writeStructEnd()
25730 
 
25731 
  def validate(self):
25732 
    return
25733 
 
25734 
 
25735 
  def __repr__(self):
25736 
    L = ['%s=%r' % (key, value)
25737 
      for key, value in self.__dict__.iteritems()]
25738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25739 
 
25740 
  def __eq__(self, other):
25741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25742 
 
25743 
  def __ne__(self, other):
25744 
    return not (self == other)
9724 kshitij.so 25745 
 
25746 
class getMarketplacedetailsForItem_args:
25747 
  """
25748 
  Attributes:
25749 
   - itemId
25750 
   - sourceId
25751 
  """
25752 
 
25753 
  thrift_spec = (
25754 
    None, # 0
25755 
    (1, TType.I64, 'itemId', None, None, ), # 1
25756 
    (2, TType.I64, 'sourceId', None, None, ), # 2
25757 
  )
25758 
 
25759 
  def __init__(self, itemId=None, sourceId=None,):
25760 
    self.itemId = itemId
25761 
    self.sourceId = sourceId
25762 
 
25763 
  def read(self, iprot):
25764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25766 
      return
25767 
    iprot.readStructBegin()
25768 
    while True:
25769 
      (fname, ftype, fid) = iprot.readFieldBegin()
25770 
      if ftype == TType.STOP:
25771 
        break
25772 
      if fid == 1:
25773 
        if ftype == TType.I64:
25774 
          self.itemId = iprot.readI64();
25775 
        else:
25776 
          iprot.skip(ftype)
25777 
      elif fid == 2:
25778 
        if ftype == TType.I64:
25779 
          self.sourceId = iprot.readI64();
25780 
        else:
25781 
          iprot.skip(ftype)
25782 
      else:
25783 
        iprot.skip(ftype)
25784 
      iprot.readFieldEnd()
25785 
    iprot.readStructEnd()
25786 
 
25787 
  def write(self, oprot):
25788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25790 
      return
25791 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
25792 
    if self.itemId is not None:
25793 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25794 
      oprot.writeI64(self.itemId)
25795 
      oprot.writeFieldEnd()
25796 
    if self.sourceId is not None:
25797 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
25798 
      oprot.writeI64(self.sourceId)
25799 
      oprot.writeFieldEnd()
25800 
    oprot.writeFieldStop()
25801 
    oprot.writeStructEnd()
25802 
 
25803 
  def validate(self):
25804 
    return
25805 
 
25806 
 
25807 
  def __repr__(self):
25808 
    L = ['%s=%r' % (key, value)
25809 
      for key, value in self.__dict__.iteritems()]
25810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25811 
 
25812 
  def __eq__(self, other):
25813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25814 
 
25815 
  def __ne__(self, other):
25816 
    return not (self == other)
25817 
 
25818 
class getMarketplacedetailsForItem_result:
25819 
  """
25820 
  Attributes:
25821 
   - success
25822 
  """
25823 
 
25824 
  thrift_spec = (
25825 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
25826 
  )
25827 
 
25828 
  def __init__(self, success=None,):
25829 
    self.success = success
25830 
 
25831 
  def read(self, iprot):
25832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25834 
      return
25835 
    iprot.readStructBegin()
25836 
    while True:
25837 
      (fname, ftype, fid) = iprot.readFieldBegin()
25838 
      if ftype == TType.STOP:
25839 
        break
25840 
      if fid == 0:
25841 
        if ftype == TType.STRUCT:
25842 
          self.success = MarketplaceItems()
25843 
          self.success.read(iprot)
25844 
        else:
25845 
          iprot.skip(ftype)
25846 
      else:
25847 
        iprot.skip(ftype)
25848 
      iprot.readFieldEnd()
25849 
    iprot.readStructEnd()
25850 
 
25851 
  def write(self, oprot):
25852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25854 
      return
25855 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
25856 
    if self.success is not None:
25857 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25858 
      self.success.write(oprot)
25859 
      oprot.writeFieldEnd()
25860 
    oprot.writeFieldStop()
25861 
    oprot.writeStructEnd()
25862 
 
25863 
  def validate(self):
25864 
    return
25865 
 
25866 
 
25867 
  def __repr__(self):
25868 
    L = ['%s=%r' % (key, value)
25869 
      for key, value in self.__dict__.iteritems()]
25870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25871 
 
25872 
  def __eq__(self, other):
25873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25874 
 
25875 
  def __ne__(self, other):
25876 
    return not (self == other)
25877 
 
25878 
class updateMarketplaceAttributesForItem_args:
25879 
  """
25880 
  Attributes:
25881 
   - marketPlaceItem
25882 
  """
25883 
 
25884 
  thrift_spec = (
25885 
    None, # 0
25886 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
25887 
  )
25888 
 
25889 
  def __init__(self, marketPlaceItem=None,):
25890 
    self.marketPlaceItem = marketPlaceItem
25891 
 
25892 
  def read(self, iprot):
25893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25895 
      return
25896 
    iprot.readStructBegin()
25897 
    while True:
25898 
      (fname, ftype, fid) = iprot.readFieldBegin()
25899 
      if ftype == TType.STOP:
25900 
        break
25901 
      if fid == 1:
25902 
        if ftype == TType.STRUCT:
25903 
          self.marketPlaceItem = MarketplaceItems()
25904 
          self.marketPlaceItem.read(iprot)
25905 
        else:
25906 
          iprot.skip(ftype)
25907 
      else:
25908 
        iprot.skip(ftype)
25909 
      iprot.readFieldEnd()
25910 
    iprot.readStructEnd()
25911 
 
25912 
  def write(self, oprot):
25913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25915 
      return
25916 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
25917 
    if self.marketPlaceItem is not None:
25918 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
25919 
      self.marketPlaceItem.write(oprot)
25920 
      oprot.writeFieldEnd()
25921 
    oprot.writeFieldStop()
25922 
    oprot.writeStructEnd()
25923 
 
25924 
  def validate(self):
25925 
    return
25926 
 
25927 
 
25928 
  def __repr__(self):
25929 
    L = ['%s=%r' % (key, value)
25930 
      for key, value in self.__dict__.iteritems()]
25931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25932 
 
25933 
  def __eq__(self, other):
25934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25935 
 
25936 
  def __ne__(self, other):
25937 
    return not (self == other)
25938 
 
25939 
class updateMarketplaceAttributesForItem_result:
25940 
  """
25941 
  Attributes:
25942 
   - success
25943 
  """
25944 
 
25945 
  thrift_spec = (
25946 
    (0, TType.BOOL, 'success', None, None, ), # 0
25947 
  )
25948 
 
25949 
  def __init__(self, success=None,):
25950 
    self.success = success
25951 
 
25952 
  def read(self, iprot):
25953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25955 
      return
25956 
    iprot.readStructBegin()
25957 
    while True:
25958 
      (fname, ftype, fid) = iprot.readFieldBegin()
25959 
      if ftype == TType.STOP:
25960 
        break
25961 
      if fid == 0:
25962 
        if ftype == TType.BOOL:
25963 
          self.success = iprot.readBool();
25964 
        else:
25965 
          iprot.skip(ftype)
25966 
      else:
25967 
        iprot.skip(ftype)
25968 
      iprot.readFieldEnd()
25969 
    iprot.readStructEnd()
25970 
 
25971 
  def write(self, oprot):
25972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25974 
      return
25975 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
25976 
    if self.success is not None:
25977 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25978 
      oprot.writeBool(self.success)
25979 
      oprot.writeFieldEnd()
25980 
    oprot.writeFieldStop()
25981 
    oprot.writeStructEnd()
25982 
 
25983 
  def validate(self):
25984 
    return
25985 
 
25986 
 
25987 
  def __repr__(self):
25988 
    L = ['%s=%r' % (key, value)
25989 
      for key, value in self.__dict__.iteritems()]
25990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25991 
 
25992 
  def __eq__(self, other):
25993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25994 
 
25995 
  def __ne__(self, other):
25996 
    return not (self == other)
9776 vikram.rag 25997 
 
9779 kshitij.so 25998 
class getCostingForMarketplace_args:
25999 
  """
26000 
  Attributes:
26001 
   - source
26002 
   - item_id
26003 
  """
26004 
 
26005 
  thrift_spec = (
26006 
    None, # 0
26007 
    (1, TType.I64, 'source', None, None, ), # 1
26008 
    (2, TType.I64, 'item_id', None, None, ), # 2
26009 
  )
26010 
 
26011 
  def __init__(self, source=None, item_id=None,):
26012 
    self.source = source
26013 
    self.item_id = item_id
26014 
 
26015 
  def read(self, iprot):
26016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26018 
      return
26019 
    iprot.readStructBegin()
26020 
    while True:
26021 
      (fname, ftype, fid) = iprot.readFieldBegin()
26022 
      if ftype == TType.STOP:
26023 
        break
26024 
      if fid == 1:
26025 
        if ftype == TType.I64:
26026 
          self.source = iprot.readI64();
26027 
        else:
26028 
          iprot.skip(ftype)
26029 
      elif fid == 2:
26030 
        if ftype == TType.I64:
26031 
          self.item_id = iprot.readI64();
26032 
        else:
26033 
          iprot.skip(ftype)
26034 
      else:
26035 
        iprot.skip(ftype)
26036 
      iprot.readFieldEnd()
26037 
    iprot.readStructEnd()
26038 
 
26039 
  def write(self, oprot):
26040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26042 
      return
26043 
    oprot.writeStructBegin('getCostingForMarketplace_args')
26044 
    if self.source is not None:
26045 
      oprot.writeFieldBegin('source', TType.I64, 1)
26046 
      oprot.writeI64(self.source)
26047 
      oprot.writeFieldEnd()
26048 
    if self.item_id is not None:
26049 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
26050 
      oprot.writeI64(self.item_id)
26051 
      oprot.writeFieldEnd()
26052 
    oprot.writeFieldStop()
26053 
    oprot.writeStructEnd()
26054 
 
26055 
  def validate(self):
26056 
    return
26057 
 
26058 
 
26059 
  def __repr__(self):
26060 
    L = ['%s=%r' % (key, value)
26061 
      for key, value in self.__dict__.iteritems()]
26062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26063 
 
26064 
  def __eq__(self, other):
26065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26066 
 
26067 
  def __ne__(self, other):
26068 
    return not (self == other)
26069 
 
26070 
class getCostingForMarketplace_result:
26071 
  """
26072 
  Attributes:
26073 
   - success
26074 
  """
26075 
 
26076 
  thrift_spec = (
26077 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
26078 
  )
26079 
 
26080 
  def __init__(self, success=None,):
26081 
    self.success = success
26082 
 
26083 
  def read(self, iprot):
26084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26086 
      return
26087 
    iprot.readStructBegin()
26088 
    while True:
26089 
      (fname, ftype, fid) = iprot.readFieldBegin()
26090 
      if ftype == TType.STOP:
26091 
        break
26092 
      if fid == 0:
26093 
        if ftype == TType.STRUCT:
26094 
          self.success = MarketplacePercentage()
26095 
          self.success.read(iprot)
26096 
        else:
26097 
          iprot.skip(ftype)
26098 
      else:
26099 
        iprot.skip(ftype)
26100 
      iprot.readFieldEnd()
26101 
    iprot.readStructEnd()
26102 
 
26103 
  def write(self, oprot):
26104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26106 
      return
26107 
    oprot.writeStructBegin('getCostingForMarketplace_result')
26108 
    if self.success is not None:
26109 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26110 
      self.success.write(oprot)
26111 
      oprot.writeFieldEnd()
26112 
    oprot.writeFieldStop()
26113 
    oprot.writeStructEnd()
26114 
 
26115 
  def validate(self):
26116 
    return
26117 
 
26118 
 
26119 
  def __repr__(self):
26120 
    L = ['%s=%r' % (key, value)
26121 
      for key, value in self.__dict__.iteritems()]
26122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26123 
 
26124 
  def __eq__(self, other):
26125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26126 
 
26127 
  def __ne__(self, other):
26128 
    return not (self == other)
26129 
 
9776 vikram.rag 26130 
class getMarketPlaceItemsForPriceUpdate_args:
26131 
  """
26132 
  Attributes:
26133 
   - source
26134 
  """
26135 
 
26136 
  thrift_spec = (
26137 
    None, # 0
26138 
    (1, TType.I64, 'source', None, None, ), # 1
26139 
  )
26140 
 
26141 
  def __init__(self, source=None,):
26142 
    self.source = source
26143 
 
26144 
  def read(self, iprot):
26145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26147 
      return
26148 
    iprot.readStructBegin()
26149 
    while True:
26150 
      (fname, ftype, fid) = iprot.readFieldBegin()
26151 
      if ftype == TType.STOP:
26152 
        break
26153 
      if fid == 1:
26154 
        if ftype == TType.I64:
26155 
          self.source = iprot.readI64();
26156 
        else:
26157 
          iprot.skip(ftype)
26158 
      else:
26159 
        iprot.skip(ftype)
26160 
      iprot.readFieldEnd()
26161 
    iprot.readStructEnd()
26162 
 
26163 
  def write(self, oprot):
26164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26166 
      return
26167 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
26168 
    if self.source is not None:
26169 
      oprot.writeFieldBegin('source', TType.I64, 1)
26170 
      oprot.writeI64(self.source)
26171 
      oprot.writeFieldEnd()
26172 
    oprot.writeFieldStop()
26173 
    oprot.writeStructEnd()
26174 
 
26175 
  def validate(self):
26176 
    return
26177 
 
26178 
 
26179 
  def __repr__(self):
26180 
    L = ['%s=%r' % (key, value)
26181 
      for key, value in self.__dict__.iteritems()]
26182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26183 
 
26184 
  def __eq__(self, other):
26185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26186 
 
26187 
  def __ne__(self, other):
26188 
    return not (self == other)
26189 
 
26190 
class getMarketPlaceItemsForPriceUpdate_result:
26191 
  """
26192 
  Attributes:
26193 
   - success
26194 
  """
26195 
 
26196 
  thrift_spec = (
26197 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
26198 
  )
26199 
 
26200 
  def __init__(self, success=None,):
26201 
    self.success = success
26202 
 
26203 
  def read(self, iprot):
26204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26206 
      return
26207 
    iprot.readStructBegin()
26208 
    while True:
26209 
      (fname, ftype, fid) = iprot.readFieldBegin()
26210 
      if ftype == TType.STOP:
26211 
        break
26212 
      if fid == 0:
26213 
        if ftype == TType.LIST:
26214 
          self.success = []
26215 
          (_etype558, _size555) = iprot.readListBegin()
26216 
          for _i559 in xrange(_size555):
26217 
            _elem560 = MarketPlaceItemPrice()
26218 
            _elem560.read(iprot)
26219 
            self.success.append(_elem560)
26220 
          iprot.readListEnd()
26221 
        else:
26222 
          iprot.skip(ftype)
26223 
      else:
26224 
        iprot.skip(ftype)
26225 
      iprot.readFieldEnd()
26226 
    iprot.readStructEnd()
26227 
 
26228 
  def write(self, oprot):
26229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26231 
      return
26232 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
26233 
    if self.success is not None:
26234 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26235 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26236 
      for iter561 in self.success:
26237 
        iter561.write(oprot)
26238 
      oprot.writeListEnd()
26239 
      oprot.writeFieldEnd()
26240 
    oprot.writeFieldStop()
26241 
    oprot.writeStructEnd()
26242 
 
26243 
  def validate(self):
26244 
    return
26245 
 
26246 
 
26247 
  def __repr__(self):
26248 
    L = ['%s=%r' % (key, value)
26249 
      for key, value in self.__dict__.iteritems()]
26250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26251 
 
26252 
  def __eq__(self, other):
26253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26254 
 
26255 
  def __ne__(self, other):
26256 
    return not (self == other)
26257 
 
26258 
class updateMarketPlacePriceUpdateStatus_args:
26259 
  """
26260 
  Attributes:
26261 
   - skulist
26262 
   - timestamp
9816 kshitij.so 26263 
   - source
9776 vikram.rag 26264 
  """
26265 
 
26266 
  thrift_spec = (
26267 
    None, # 0
26268 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
26269 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 26270 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 26271 
  )
26272 
 
9816 kshitij.so 26273 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 26274 
    self.skulist = skulist
26275 
    self.timestamp = timestamp
9816 kshitij.so 26276 
    self.source = source
9776 vikram.rag 26277 
 
26278 
  def read(self, iprot):
26279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26281 
      return
26282 
    iprot.readStructBegin()
26283 
    while True:
26284 
      (fname, ftype, fid) = iprot.readFieldBegin()
26285 
      if ftype == TType.STOP:
26286 
        break
26287 
      if fid == 1:
26288 
        if ftype == TType.LIST:
26289 
          self.skulist = []
26290 
          (_etype565, _size562) = iprot.readListBegin()
26291 
          for _i566 in xrange(_size562):
26292 
            _elem567 = iprot.readI64();
26293 
            self.skulist.append(_elem567)
26294 
          iprot.readListEnd()
26295 
        else:
26296 
          iprot.skip(ftype)
26297 
      elif fid == 2:
26298 
        if ftype == TType.I64:
26299 
          self.timestamp = iprot.readI64();
26300 
        else:
26301 
          iprot.skip(ftype)
9816 kshitij.so 26302 
      elif fid == 3:
26303 
        if ftype == TType.I64:
26304 
          self.source = iprot.readI64();
26305 
        else:
26306 
          iprot.skip(ftype)
9776 vikram.rag 26307 
      else:
26308 
        iprot.skip(ftype)
26309 
      iprot.readFieldEnd()
26310 
    iprot.readStructEnd()
26311 
 
26312 
  def write(self, oprot):
26313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26315 
      return
26316 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
26317 
    if self.skulist is not None:
26318 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
26319 
      oprot.writeListBegin(TType.I64, len(self.skulist))
26320 
      for iter568 in self.skulist:
26321 
        oprot.writeI64(iter568)
26322 
      oprot.writeListEnd()
26323 
      oprot.writeFieldEnd()
26324 
    if self.timestamp is not None:
26325 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
26326 
      oprot.writeI64(self.timestamp)
26327 
      oprot.writeFieldEnd()
9816 kshitij.so 26328 
    if self.source is not None:
26329 
      oprot.writeFieldBegin('source', TType.I64, 3)
26330 
      oprot.writeI64(self.source)
26331 
      oprot.writeFieldEnd()
9776 vikram.rag 26332 
    oprot.writeFieldStop()
26333 
    oprot.writeStructEnd()
26334 
 
26335 
  def validate(self):
26336 
    return
26337 
 
26338 
 
26339 
  def __repr__(self):
26340 
    L = ['%s=%r' % (key, value)
26341 
      for key, value in self.__dict__.iteritems()]
26342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26343 
 
26344 
  def __eq__(self, other):
26345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26346 
 
26347 
  def __ne__(self, other):
26348 
    return not (self == other)
26349 
 
26350 
class updateMarketPlacePriceUpdateStatus_result:
26351 
 
26352 
  thrift_spec = (
26353 
  )
26354 
 
26355 
  def read(self, iprot):
26356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26358 
      return
26359 
    iprot.readStructBegin()
26360 
    while True:
26361 
      (fname, ftype, fid) = iprot.readFieldBegin()
26362 
      if ftype == TType.STOP:
26363 
        break
26364 
      else:
26365 
        iprot.skip(ftype)
26366 
      iprot.readFieldEnd()
26367 
    iprot.readStructEnd()
26368 
 
26369 
  def write(self, oprot):
26370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26372 
      return
26373 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
26374 
    oprot.writeFieldStop()
26375 
    oprot.writeStructEnd()
26376 
 
26377 
  def validate(self):
26378 
    return
26379 
 
26380 
 
26381 
  def __repr__(self):
26382 
    L = ['%s=%r' % (key, value)
26383 
      for key, value in self.__dict__.iteritems()]
26384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26385 
 
26386 
  def __eq__(self, other):
26387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26388 
 
26389 
  def __ne__(self, other):
26390 
    return not (self == other)
9861 rajveer 26391 
 
26392 
class updateItemHoldInventory_args:
26393 
  """
26394 
  Attributes:
26395 
   - itemHoldMap
26396 
  """
26397 
 
26398 
  thrift_spec = (
26399 
    None, # 0
26400 
    (1, TType.MAP, 'itemHoldMap', (TType.I64,None,TType.I64,None), None, ), # 1
26401 
  )
26402 
 
26403 
  def __init__(self, itemHoldMap=None,):
26404 
    self.itemHoldMap = itemHoldMap
26405 
 
26406 
  def read(self, iprot):
26407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26409 
      return
26410 
    iprot.readStructBegin()
26411 
    while True:
26412 
      (fname, ftype, fid) = iprot.readFieldBegin()
26413 
      if ftype == TType.STOP:
26414 
        break
26415 
      if fid == 1:
26416 
        if ftype == TType.MAP:
26417 
          self.itemHoldMap = {}
26418 
          (_ktype570, _vtype571, _size569 ) = iprot.readMapBegin()
26419 
          for _i573 in xrange(_size569):
26420 
            _key574 = iprot.readI64();
26421 
            _val575 = iprot.readI64();
26422 
            self.itemHoldMap[_key574] = _val575
26423 
          iprot.readMapEnd()
26424 
        else:
26425 
          iprot.skip(ftype)
26426 
      else:
26427 
        iprot.skip(ftype)
26428 
      iprot.readFieldEnd()
26429 
    iprot.readStructEnd()
26430 
 
26431 
  def write(self, oprot):
26432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26434 
      return
26435 
    oprot.writeStructBegin('updateItemHoldInventory_args')
26436 
    if self.itemHoldMap is not None:
26437 
      oprot.writeFieldBegin('itemHoldMap', TType.MAP, 1)
26438 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemHoldMap))
26439 
      for kiter576,viter577 in self.itemHoldMap.items():
26440 
        oprot.writeI64(kiter576)
26441 
        oprot.writeI64(viter577)
26442 
      oprot.writeMapEnd()
26443 
      oprot.writeFieldEnd()
26444 
    oprot.writeFieldStop()
26445 
    oprot.writeStructEnd()
26446 
 
26447 
  def validate(self):
26448 
    return
26449 
 
26450 
 
26451 
  def __repr__(self):
26452 
    L = ['%s=%r' % (key, value)
26453 
      for key, value in self.__dict__.iteritems()]
26454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26455 
 
26456 
  def __eq__(self, other):
26457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26458 
 
26459 
  def __ne__(self, other):
26460 
    return not (self == other)
26461 
 
26462 
class updateItemHoldInventory_result:
26463 
 
26464 
  thrift_spec = (
26465 
  )
26466 
 
26467 
  def read(self, iprot):
26468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26470 
      return
26471 
    iprot.readStructBegin()
26472 
    while True:
26473 
      (fname, ftype, fid) = iprot.readFieldBegin()
26474 
      if ftype == TType.STOP:
26475 
        break
26476 
      else:
26477 
        iprot.skip(ftype)
26478 
      iprot.readFieldEnd()
26479 
    iprot.readStructEnd()
26480 
 
26481 
  def write(self, oprot):
26482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26484 
      return
26485 
    oprot.writeStructBegin('updateItemHoldInventory_result')
26486 
    oprot.writeFieldStop()
26487 
    oprot.writeStructEnd()
26488 
 
26489 
  def validate(self):
26490 
    return
26491 
 
26492 
 
26493 
  def __repr__(self):
26494 
    L = ['%s=%r' % (key, value)
26495 
      for key, value in self.__dict__.iteritems()]
26496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26497 
 
26498 
  def __eq__(self, other):
26499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26500 
 
26501 
  def __ne__(self, other):
26502 
    return not (self == other)
9895 vikram.rag 26503 
 
26504 
class updateNlcAtMarketplaces_args:
26505 
  """
26506 
  Attributes:
26507 
   - item_id
26508 
   - vendor_id
26509 
   - nlc
26510 
  """
26511 
 
26512 
  thrift_spec = None
26513 
  def __init__(self, item_id=None, vendor_id=None, nlc=None,):
26514 
    self.item_id = item_id
26515 
    self.vendor_id = vendor_id
26516 
    self.nlc = nlc
26517 
 
26518 
  def read(self, iprot):
26519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26521 
      return
26522 
    iprot.readStructBegin()
26523 
    while True:
26524 
      (fname, ftype, fid) = iprot.readFieldBegin()
26525 
      if ftype == TType.STOP:
26526 
        break
26527 
      if fid == 1:
26528 
        if ftype == TType.I64:
26529 
          self.item_id = iprot.readI64();
26530 
        else:
26531 
          iprot.skip(ftype)
26532 
      elif fid == 2:
26533 
        if ftype == TType.I64:
26534 
          self.vendor_id = iprot.readI64();
26535 
        else:
26536 
          iprot.skip(ftype)
26537 
      elif fid == -1:
26538 
        if ftype == TType.DOUBLE:
26539 
          self.nlc = iprot.readDouble();
26540 
        else:
26541 
          iprot.skip(ftype)
26542 
      else:
26543 
        iprot.skip(ftype)
26544 
      iprot.readFieldEnd()
26545 
    iprot.readStructEnd()
26546 
 
26547 
  def write(self, oprot):
26548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26550 
      return
26551 
    oprot.writeStructBegin('updateNlcAtMarketplaces_args')
26552 
    if self.nlc is not None:
26553 
      oprot.writeFieldBegin('nlc', TType.DOUBLE, -1)
26554 
      oprot.writeDouble(self.nlc)
26555 
      oprot.writeFieldEnd()
26556 
    if self.item_id is not None:
26557 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26558 
      oprot.writeI64(self.item_id)
26559 
      oprot.writeFieldEnd()
26560 
    if self.vendor_id is not None:
26561 
      oprot.writeFieldBegin('vendor_id', TType.I64, 2)
26562 
      oprot.writeI64(self.vendor_id)
26563 
      oprot.writeFieldEnd()
26564 
    oprot.writeFieldStop()
26565 
    oprot.writeStructEnd()
26566 
 
26567 
  def validate(self):
26568 
    return
26569 
 
26570 
 
26571 
  def __repr__(self):
26572 
    L = ['%s=%r' % (key, value)
26573 
      for key, value in self.__dict__.iteritems()]
26574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26575 
 
26576 
  def __eq__(self, other):
26577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26578 
 
26579 
  def __ne__(self, other):
26580 
    return not (self == other)
26581 
 
26582 
class updateNlcAtMarketplaces_result:
26583 
 
26584 
  thrift_spec = (
26585 
  )
26586 
 
26587 
  def read(self, iprot):
26588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26590 
      return
26591 
    iprot.readStructBegin()
26592 
    while True:
26593 
      (fname, ftype, fid) = iprot.readFieldBegin()
26594 
      if ftype == TType.STOP:
26595 
        break
26596 
      else:
26597 
        iprot.skip(ftype)
26598 
      iprot.readFieldEnd()
26599 
    iprot.readStructEnd()
26600 
 
26601 
  def write(self, oprot):
26602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26604 
      return
26605 
    oprot.writeStructBegin('updateNlcAtMarketplaces_result')
26606 
    oprot.writeFieldStop()
26607 
    oprot.writeStructEnd()
26608 
 
26609 
  def validate(self):
26610 
    return
26611 
 
26612 
 
26613 
  def __repr__(self):
26614 
    L = ['%s=%r' % (key, value)
26615 
      for key, value in self.__dict__.iteritems()]
26616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26617 
 
26618 
  def __eq__(self, other):
26619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26620 
 
26621 
  def __ne__(self, other):
26622 
    return not (self == other)
9945 vikram.rag 26623 
 
26624 
class getAllFlipkartItems_args:
26625 
 
26626 
  thrift_spec = (
26627 
  )
26628 
 
26629 
  def read(self, iprot):
26630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26632 
      return
26633 
    iprot.readStructBegin()
26634 
    while True:
26635 
      (fname, ftype, fid) = iprot.readFieldBegin()
26636 
      if ftype == TType.STOP:
26637 
        break
26638 
      else:
26639 
        iprot.skip(ftype)
26640 
      iprot.readFieldEnd()
26641 
    iprot.readStructEnd()
26642 
 
26643 
  def write(self, oprot):
26644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26646 
      return
26647 
    oprot.writeStructBegin('getAllFlipkartItems_args')
26648 
    oprot.writeFieldStop()
26649 
    oprot.writeStructEnd()
26650 
 
26651 
  def validate(self):
26652 
    return
26653 
 
26654 
 
26655 
  def __repr__(self):
26656 
    L = ['%s=%r' % (key, value)
26657 
      for key, value in self.__dict__.iteritems()]
26658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26659 
 
26660 
  def __eq__(self, other):
26661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26662 
 
26663 
  def __ne__(self, other):
26664 
    return not (self == other)
26665 
 
26666 
class getAllFlipkartItems_result:
26667 
  """
26668 
  Attributes:
26669 
   - success
26670 
  """
26671 
 
26672 
  thrift_spec = (
26673 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
26674 
  )
26675 
 
26676 
  def __init__(self, success=None,):
26677 
    self.success = success
26678 
 
26679 
  def read(self, iprot):
26680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26682 
      return
26683 
    iprot.readStructBegin()
26684 
    while True:
26685 
      (fname, ftype, fid) = iprot.readFieldBegin()
26686 
      if ftype == TType.STOP:
26687 
        break
26688 
      if fid == 0:
26689 
        if ftype == TType.LIST:
26690 
          self.success = []
26691 
          (_etype581, _size578) = iprot.readListBegin()
26692 
          for _i582 in xrange(_size578):
26693 
            _elem583 = FlipkartItem()
26694 
            _elem583.read(iprot)
26695 
            self.success.append(_elem583)
26696 
          iprot.readListEnd()
26697 
        else:
26698 
          iprot.skip(ftype)
26699 
      else:
26700 
        iprot.skip(ftype)
26701 
      iprot.readFieldEnd()
26702 
    iprot.readStructEnd()
26703 
 
26704 
  def write(self, oprot):
26705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26707 
      return
26708 
    oprot.writeStructBegin('getAllFlipkartItems_result')
26709 
    if self.success is not None:
26710 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26711 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26712 
      for iter584 in self.success:
26713 
        iter584.write(oprot)
26714 
      oprot.writeListEnd()
26715 
      oprot.writeFieldEnd()
26716 
    oprot.writeFieldStop()
26717 
    oprot.writeStructEnd()
26718 
 
26719 
  def validate(self):
26720 
    return
26721 
 
26722 
 
26723 
  def __repr__(self):
26724 
    L = ['%s=%r' % (key, value)
26725 
      for key, value in self.__dict__.iteritems()]
26726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26727 
 
26728 
  def __eq__(self, other):
26729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26730 
 
26731 
  def __ne__(self, other):
26732 
    return not (self == other)
10097 kshitij.so 26733 
 
26734 
class addOrUpdateFlipkartItem_args:
26735 
  """
26736 
  Attributes:
26737 
   - flipkartitem
26738 
  """
26739 
 
26740 
  thrift_spec = None
26741 
  def __init__(self, flipkartitem=None,):
26742 
    self.flipkartitem = flipkartitem
26743 
 
26744 
  def read(self, iprot):
26745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26747 
      return
26748 
    iprot.readStructBegin()
26749 
    while True:
26750 
      (fname, ftype, fid) = iprot.readFieldBegin()
26751 
      if ftype == TType.STOP:
26752 
        break
26753 
      if fid == -1:
26754 
        if ftype == TType.STRUCT:
26755 
          self.flipkartitem = FlipkartItem()
26756 
          self.flipkartitem.read(iprot)
26757 
        else:
26758 
          iprot.skip(ftype)
26759 
      else:
26760 
        iprot.skip(ftype)
26761 
      iprot.readFieldEnd()
26762 
    iprot.readStructEnd()
26763 
 
26764 
  def write(self, oprot):
26765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26767 
      return
26768 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_args')
26769 
    if self.flipkartitem is not None:
26770 
      oprot.writeFieldBegin('flipkartitem', TType.STRUCT, -1)
26771 
      self.flipkartitem.write(oprot)
26772 
      oprot.writeFieldEnd()
26773 
    oprot.writeFieldStop()
26774 
    oprot.writeStructEnd()
26775 
 
26776 
  def validate(self):
26777 
    return
26778 
 
26779 
 
26780 
  def __repr__(self):
26781 
    L = ['%s=%r' % (key, value)
26782 
      for key, value in self.__dict__.iteritems()]
26783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26784 
 
26785 
  def __eq__(self, other):
26786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26787 
 
26788 
  def __ne__(self, other):
26789 
    return not (self == other)
26790 
 
26791 
class addOrUpdateFlipkartItem_result:
26792 
  """
26793 
  Attributes:
26794 
   - success
26795 
  """
26796 
 
26797 
  thrift_spec = (
26798 
    (0, TType.BOOL, 'success', None, None, ), # 0
26799 
  )
26800 
 
26801 
  def __init__(self, success=None,):
26802 
    self.success = success
26803 
 
26804 
  def read(self, iprot):
26805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26807 
      return
26808 
    iprot.readStructBegin()
26809 
    while True:
26810 
      (fname, ftype, fid) = iprot.readFieldBegin()
26811 
      if ftype == TType.STOP:
26812 
        break
26813 
      if fid == 0:
26814 
        if ftype == TType.BOOL:
26815 
          self.success = iprot.readBool();
26816 
        else:
26817 
          iprot.skip(ftype)
26818 
      else:
26819 
        iprot.skip(ftype)
26820 
      iprot.readFieldEnd()
26821 
    iprot.readStructEnd()
26822 
 
26823 
  def write(self, oprot):
26824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26826 
      return
26827 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_result')
26828 
    if self.success is not None:
26829 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26830 
      oprot.writeBool(self.success)
26831 
      oprot.writeFieldEnd()
26832 
    oprot.writeFieldStop()
26833 
    oprot.writeStructEnd()
26834 
 
26835 
  def validate(self):
26836 
    return
26837 
 
26838 
 
26839 
  def __repr__(self):
26840 
    L = ['%s=%r' % (key, value)
26841 
      for key, value in self.__dict__.iteritems()]
26842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26843 
 
26844 
  def __eq__(self, other):
26845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26846 
 
26847 
  def __ne__(self, other):
26848 
    return not (self == other)
26849 
 
26850 
class getFlipkartItem_args:
26851 
  """
26852 
  Attributes:
26853 
   - item_id
26854 
  """
26855 
 
26856 
  thrift_spec = (
26857 
    None, # 0
26858 
    (1, TType.I64, 'item_id', None, None, ), # 1
26859 
  )
26860 
 
26861 
  def __init__(self, item_id=None,):
26862 
    self.item_id = item_id
26863 
 
26864 
  def read(self, iprot):
26865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26867 
      return
26868 
    iprot.readStructBegin()
26869 
    while True:
26870 
      (fname, ftype, fid) = iprot.readFieldBegin()
26871 
      if ftype == TType.STOP:
26872 
        break
26873 
      if fid == 1:
26874 
        if ftype == TType.I64:
26875 
          self.item_id = iprot.readI64();
26876 
        else:
26877 
          iprot.skip(ftype)
26878 
      else:
26879 
        iprot.skip(ftype)
26880 
      iprot.readFieldEnd()
26881 
    iprot.readStructEnd()
26882 
 
26883 
  def write(self, oprot):
26884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26886 
      return
26887 
    oprot.writeStructBegin('getFlipkartItem_args')
26888 
    if self.item_id is not None:
26889 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26890 
      oprot.writeI64(self.item_id)
26891 
      oprot.writeFieldEnd()
26892 
    oprot.writeFieldStop()
26893 
    oprot.writeStructEnd()
26894 
 
26895 
  def validate(self):
26896 
    return
26897 
 
26898 
 
26899 
  def __repr__(self):
26900 
    L = ['%s=%r' % (key, value)
26901 
      for key, value in self.__dict__.iteritems()]
26902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26903 
 
26904 
  def __eq__(self, other):
26905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26906 
 
26907 
  def __ne__(self, other):
26908 
    return not (self == other)
26909 
 
26910 
class getFlipkartItem_result:
26911 
  """
26912 
  Attributes:
26913 
   - success
26914 
  """
26915 
 
26916 
  thrift_spec = (
26917 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
26918 
  )
26919 
 
26920 
  def __init__(self, success=None,):
26921 
    self.success = success
26922 
 
26923 
  def read(self, iprot):
26924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26926 
      return
26927 
    iprot.readStructBegin()
26928 
    while True:
26929 
      (fname, ftype, fid) = iprot.readFieldBegin()
26930 
      if ftype == TType.STOP:
26931 
        break
26932 
      if fid == 0:
26933 
        if ftype == TType.STRUCT:
26934 
          self.success = FlipkartItem()
26935 
          self.success.read(iprot)
26936 
        else:
26937 
          iprot.skip(ftype)
26938 
      else:
26939 
        iprot.skip(ftype)
26940 
      iprot.readFieldEnd()
26941 
    iprot.readStructEnd()
26942 
 
26943 
  def write(self, oprot):
26944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26946 
      return
26947 
    oprot.writeStructBegin('getFlipkartItem_result')
26948 
    if self.success is not None:
26949 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26950 
      self.success.write(oprot)
26951 
      oprot.writeFieldEnd()
26952 
    oprot.writeFieldStop()
26953 
    oprot.writeStructEnd()
26954 
 
26955 
  def validate(self):
26956 
    return
26957 
 
26958 
 
26959 
  def __repr__(self):
26960 
    L = ['%s=%r' % (key, value)
26961 
      for key, value in self.__dict__.iteritems()]
26962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26963 
 
26964 
  def __eq__(self, other):
26965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26966 
 
26967 
  def __ne__(self, other):
26968 
    return not (self == other)
26969 
 
26970 
class getFlipkartItemDetails_args:
26971 
  """
26972 
  Attributes:
26973 
   - item_id
26974 
  """
26975 
 
26976 
  thrift_spec = (
26977 
    None, # 0
26978 
    (1, TType.I64, 'item_id', None, None, ), # 1
26979 
  )
26980 
 
26981 
  def __init__(self, item_id=None,):
26982 
    self.item_id = item_id
26983 
 
26984 
  def read(self, iprot):
26985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26987 
      return
26988 
    iprot.readStructBegin()
26989 
    while True:
26990 
      (fname, ftype, fid) = iprot.readFieldBegin()
26991 
      if ftype == TType.STOP:
26992 
        break
26993 
      if fid == 1:
26994 
        if ftype == TType.I64:
26995 
          self.item_id = iprot.readI64();
26996 
        else:
26997 
          iprot.skip(ftype)
26998 
      else:
26999 
        iprot.skip(ftype)
27000 
      iprot.readFieldEnd()
27001 
    iprot.readStructEnd()
27002 
 
27003 
  def write(self, oprot):
27004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27006 
      return
27007 
    oprot.writeStructBegin('getFlipkartItemDetails_args')
27008 
    if self.item_id is not None:
27009 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
27010 
      oprot.writeI64(self.item_id)
27011 
      oprot.writeFieldEnd()
27012 
    oprot.writeFieldStop()
27013 
    oprot.writeStructEnd()
27014 
 
27015 
  def validate(self):
27016 
    return
27017 
 
27018 
 
27019 
  def __repr__(self):
27020 
    L = ['%s=%r' % (key, value)
27021 
      for key, value in self.__dict__.iteritems()]
27022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27023 
 
27024 
  def __eq__(self, other):
27025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27026 
 
27027 
  def __ne__(self, other):
27028 
    return not (self == other)
27029 
 
27030 
class getFlipkartItemDetails_result:
27031 
  """
27032 
  Attributes:
27033 
   - success
27034 
  """
27035 
 
27036 
  thrift_spec = (
27037 
    (0, TType.STRUCT, 'success', (FlipkartItemDetails, FlipkartItemDetails.thrift_spec), None, ), # 0
27038 
  )
27039 
 
27040 
  def __init__(self, success=None,):
27041 
    self.success = success
27042 
 
27043 
  def read(self, iprot):
27044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27046 
      return
27047 
    iprot.readStructBegin()
27048 
    while True:
27049 
      (fname, ftype, fid) = iprot.readFieldBegin()
27050 
      if ftype == TType.STOP:
27051 
        break
27052 
      if fid == 0:
27053 
        if ftype == TType.STRUCT:
27054 
          self.success = FlipkartItemDetails()
27055 
          self.success.read(iprot)
27056 
        else:
27057 
          iprot.skip(ftype)
27058 
      else:
27059 
        iprot.skip(ftype)
27060 
      iprot.readFieldEnd()
27061 
    iprot.readStructEnd()
27062 
 
27063 
  def write(self, oprot):
27064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27066 
      return
27067 
    oprot.writeStructBegin('getFlipkartItemDetails_result')
27068 
    if self.success is not None:
27069 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27070 
      self.success.write(oprot)
27071 
      oprot.writeFieldEnd()
27072 
    oprot.writeFieldStop()
27073 
    oprot.writeStructEnd()
27074 
 
27075 
  def validate(self):
27076 
    return
27077 
 
27078 
 
27079 
  def __repr__(self):
27080 
    L = ['%s=%r' % (key, value)
27081 
      for key, value in self.__dict__.iteritems()]
27082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27083 
 
27084 
  def __eq__(self, other):
27085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27086 
 
27087 
  def __ne__(self, other):
27088 
    return not (self == other)
27089 
 
27090 
class getFlipkartItems_args:
27091 
  """
27092 
  Attributes:
27093 
   - offset
27094 
   - limit
27095 
  """
27096 
 
27097 
  thrift_spec = (
27098 
    None, # 0
27099 
    (1, TType.I64, 'offset', None, None, ), # 1
27100 
    (2, TType.I64, 'limit', None, None, ), # 2
27101 
  )
27102 
 
27103 
  def __init__(self, offset=None, limit=None,):
27104 
    self.offset = offset
27105 
    self.limit = limit
27106 
 
27107 
  def read(self, iprot):
27108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27110 
      return
27111 
    iprot.readStructBegin()
27112 
    while True:
27113 
      (fname, ftype, fid) = iprot.readFieldBegin()
27114 
      if ftype == TType.STOP:
27115 
        break
27116 
      if fid == 1:
27117 
        if ftype == TType.I64:
27118 
          self.offset = iprot.readI64();
27119 
        else:
27120 
          iprot.skip(ftype)
27121 
      elif fid == 2:
27122 
        if ftype == TType.I64:
27123 
          self.limit = iprot.readI64();
27124 
        else:
27125 
          iprot.skip(ftype)
27126 
      else:
27127 
        iprot.skip(ftype)
27128 
      iprot.readFieldEnd()
27129 
    iprot.readStructEnd()
27130 
 
27131 
  def write(self, oprot):
27132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27134 
      return
27135 
    oprot.writeStructBegin('getFlipkartItems_args')
27136 
    if self.offset is not None:
27137 
      oprot.writeFieldBegin('offset', TType.I64, 1)
27138 
      oprot.writeI64(self.offset)
27139 
      oprot.writeFieldEnd()
27140 
    if self.limit is not None:
27141 
      oprot.writeFieldBegin('limit', TType.I64, 2)
27142 
      oprot.writeI64(self.limit)
27143 
      oprot.writeFieldEnd()
27144 
    oprot.writeFieldStop()
27145 
    oprot.writeStructEnd()
27146 
 
27147 
  def validate(self):
27148 
    return
27149 
 
27150 
 
27151 
  def __repr__(self):
27152 
    L = ['%s=%r' % (key, value)
27153 
      for key, value in self.__dict__.iteritems()]
27154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27155 
 
27156 
  def __eq__(self, other):
27157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27158 
 
27159 
  def __ne__(self, other):
27160 
    return not (self == other)
27161 
 
27162 
class getFlipkartItems_result:
27163 
  """
27164 
  Attributes:
27165 
   - success
27166 
  """
27167 
 
27168 
  thrift_spec = (
27169 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27170 
  )
27171 
 
27172 
  def __init__(self, success=None,):
27173 
    self.success = success
27174 
 
27175 
  def read(self, iprot):
27176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27178 
      return
27179 
    iprot.readStructBegin()
27180 
    while True:
27181 
      (fname, ftype, fid) = iprot.readFieldBegin()
27182 
      if ftype == TType.STOP:
27183 
        break
27184 
      if fid == 0:
27185 
        if ftype == TType.LIST:
27186 
          self.success = []
27187 
          (_etype588, _size585) = iprot.readListBegin()
27188 
          for _i589 in xrange(_size585):
27189 
            _elem590 = FlipkartItemDetails()
27190 
            _elem590.read(iprot)
27191 
            self.success.append(_elem590)
27192 
          iprot.readListEnd()
27193 
        else:
27194 
          iprot.skip(ftype)
27195 
      else:
27196 
        iprot.skip(ftype)
27197 
      iprot.readFieldEnd()
27198 
    iprot.readStructEnd()
27199 
 
27200 
  def write(self, oprot):
27201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27203 
      return
27204 
    oprot.writeStructBegin('getFlipkartItems_result')
27205 
    if self.success is not None:
27206 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27207 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27208 
      for iter591 in self.success:
27209 
        iter591.write(oprot)
27210 
      oprot.writeListEnd()
27211 
      oprot.writeFieldEnd()
27212 
    oprot.writeFieldStop()
27213 
    oprot.writeStructEnd()
27214 
 
27215 
  def validate(self):
27216 
    return
27217 
 
27218 
 
27219 
  def __repr__(self):
27220 
    L = ['%s=%r' % (key, value)
27221 
      for key, value in self.__dict__.iteritems()]
27222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27223 
 
27224 
  def __eq__(self, other):
27225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27226 
 
27227 
  def __ne__(self, other):
27228 
    return not (self == other)
27229 
 
27230 
class searchFlipkartItems_args:
27231 
  """
27232 
  Attributes:
27233 
   - searchTerm
27234 
   - offset
27235 
   - limit
27236 
  """
27237 
 
27238 
  thrift_spec = (
27239 
    None, # 0
27240 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
27241 
    (2, TType.I64, 'offset', None, None, ), # 2
27242 
    (3, TType.I64, 'limit', None, None, ), # 3
27243 
  )
27244 
 
27245 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
27246 
    self.searchTerm = searchTerm
27247 
    self.offset = offset
27248 
    self.limit = limit
27249 
 
27250 
  def read(self, iprot):
27251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27253 
      return
27254 
    iprot.readStructBegin()
27255 
    while True:
27256 
      (fname, ftype, fid) = iprot.readFieldBegin()
27257 
      if ftype == TType.STOP:
27258 
        break
27259 
      if fid == 1:
27260 
        if ftype == TType.LIST:
27261 
          self.searchTerm = []
27262 
          (_etype595, _size592) = iprot.readListBegin()
27263 
          for _i596 in xrange(_size592):
27264 
            _elem597 = iprot.readString();
27265 
            self.searchTerm.append(_elem597)
27266 
          iprot.readListEnd()
27267 
        else:
27268 
          iprot.skip(ftype)
27269 
      elif fid == 2:
27270 
        if ftype == TType.I64:
27271 
          self.offset = iprot.readI64();
27272 
        else:
27273 
          iprot.skip(ftype)
27274 
      elif fid == 3:
27275 
        if ftype == TType.I64:
27276 
          self.limit = iprot.readI64();
27277 
        else:
27278 
          iprot.skip(ftype)
27279 
      else:
27280 
        iprot.skip(ftype)
27281 
      iprot.readFieldEnd()
27282 
    iprot.readStructEnd()
27283 
 
27284 
  def write(self, oprot):
27285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27287 
      return
27288 
    oprot.writeStructBegin('searchFlipkartItems_args')
27289 
    if self.searchTerm is not None:
27290 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
27291 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
27292 
      for iter598 in self.searchTerm:
27293 
        oprot.writeString(iter598)
27294 
      oprot.writeListEnd()
27295 
      oprot.writeFieldEnd()
27296 
    if self.offset is not None:
27297 
      oprot.writeFieldBegin('offset', TType.I64, 2)
27298 
      oprot.writeI64(self.offset)
27299 
      oprot.writeFieldEnd()
27300 
    if self.limit is not None:
27301 
      oprot.writeFieldBegin('limit', TType.I64, 3)
27302 
      oprot.writeI64(self.limit)
27303 
      oprot.writeFieldEnd()
27304 
    oprot.writeFieldStop()
27305 
    oprot.writeStructEnd()
27306 
 
27307 
  def validate(self):
27308 
    return
27309 
 
27310 
 
27311 
  def __repr__(self):
27312 
    L = ['%s=%r' % (key, value)
27313 
      for key, value in self.__dict__.iteritems()]
27314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27315 
 
27316 
  def __eq__(self, other):
27317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27318 
 
27319 
  def __ne__(self, other):
27320 
    return not (self == other)
27321 
 
27322 
class searchFlipkartItems_result:
27323 
  """
27324 
  Attributes:
27325 
   - success
27326 
  """
27327 
 
27328 
  thrift_spec = (
27329 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27330 
  )
27331 
 
27332 
  def __init__(self, success=None,):
27333 
    self.success = success
27334 
 
27335 
  def read(self, iprot):
27336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27338 
      return
27339 
    iprot.readStructBegin()
27340 
    while True:
27341 
      (fname, ftype, fid) = iprot.readFieldBegin()
27342 
      if ftype == TType.STOP:
27343 
        break
27344 
      if fid == 0:
27345 
        if ftype == TType.LIST:
27346 
          self.success = []
27347 
          (_etype602, _size599) = iprot.readListBegin()
27348 
          for _i603 in xrange(_size599):
27349 
            _elem604 = FlipkartItemDetails()
27350 
            _elem604.read(iprot)
27351 
            self.success.append(_elem604)
27352 
          iprot.readListEnd()
27353 
        else:
27354 
          iprot.skip(ftype)
27355 
      else:
27356 
        iprot.skip(ftype)
27357 
      iprot.readFieldEnd()
27358 
    iprot.readStructEnd()
27359 
 
27360 
  def write(self, oprot):
27361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27363 
      return
27364 
    oprot.writeStructBegin('searchFlipkartItems_result')
27365 
    if self.success is not None:
27366 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27367 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27368 
      for iter605 in self.success:
27369 
        iter605.write(oprot)
27370 
      oprot.writeListEnd()
27371 
      oprot.writeFieldEnd()
27372 
    oprot.writeFieldStop()
27373 
    oprot.writeStructEnd()
27374 
 
27375 
  def validate(self):
27376 
    return
27377 
 
27378 
 
27379 
  def __repr__(self):
27380 
    L = ['%s=%r' % (key, value)
27381 
      for key, value in self.__dict__.iteritems()]
27382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27383 
 
27384 
  def __eq__(self, other):
27385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27386 
 
27387 
  def __ne__(self, other):
27388 
    return not (self == other)
27389 
 
27390 
class getCountForFlipkartItems_args:
27391 
 
27392 
  thrift_spec = (
27393 
  )
27394 
 
27395 
  def read(self, iprot):
27396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27398 
      return
27399 
    iprot.readStructBegin()
27400 
    while True:
27401 
      (fname, ftype, fid) = iprot.readFieldBegin()
27402 
      if ftype == TType.STOP:
27403 
        break
27404 
      else:
27405 
        iprot.skip(ftype)
27406 
      iprot.readFieldEnd()
27407 
    iprot.readStructEnd()
27408 
 
27409 
  def write(self, oprot):
27410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27412 
      return
27413 
    oprot.writeStructBegin('getCountForFlipkartItems_args')
27414 
    oprot.writeFieldStop()
27415 
    oprot.writeStructEnd()
27416 
 
27417 
  def validate(self):
27418 
    return
27419 
 
27420 
 
27421 
  def __repr__(self):
27422 
    L = ['%s=%r' % (key, value)
27423 
      for key, value in self.__dict__.iteritems()]
27424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27425 
 
27426 
  def __eq__(self, other):
27427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27428 
 
27429 
  def __ne__(self, other):
27430 
    return not (self == other)
27431 
 
27432 
class getCountForFlipkartItems_result:
27433 
  """
27434 
  Attributes:
27435 
   - success
27436 
  """
27437 
 
27438 
  thrift_spec = (
27439 
    (0, TType.I64, 'success', None, None, ), # 0
27440 
  )
27441 
 
27442 
  def __init__(self, success=None,):
27443 
    self.success = success
27444 
 
27445 
  def read(self, iprot):
27446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27448 
      return
27449 
    iprot.readStructBegin()
27450 
    while True:
27451 
      (fname, ftype, fid) = iprot.readFieldBegin()
27452 
      if ftype == TType.STOP:
27453 
        break
27454 
      if fid == 0:
27455 
        if ftype == TType.I64:
27456 
          self.success = iprot.readI64();
27457 
        else:
27458 
          iprot.skip(ftype)
27459 
      else:
27460 
        iprot.skip(ftype)
27461 
      iprot.readFieldEnd()
27462 
    iprot.readStructEnd()
27463 
 
27464 
  def write(self, oprot):
27465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27467 
      return
27468 
    oprot.writeStructBegin('getCountForFlipkartItems_result')
27469 
    if self.success is not None:
27470 
      oprot.writeFieldBegin('success', TType.I64, 0)
27471 
      oprot.writeI64(self.success)
27472 
      oprot.writeFieldEnd()
27473 
    oprot.writeFieldStop()
27474 
    oprot.writeStructEnd()
27475 
 
27476 
  def validate(self):
27477 
    return
27478 
 
27479 
 
27480 
  def __repr__(self):
27481 
    L = ['%s=%r' % (key, value)
27482 
      for key, value in self.__dict__.iteritems()]
27483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27484 
 
27485 
  def __eq__(self, other):
27486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27487 
 
27488 
  def __ne__(self, other):
27489 
    return not (self == other)
27490 
 
27491 
class getFlipkartSearchResultCount_args:
27492 
  """
27493 
  Attributes:
27494 
   - searchTerm
27495 
  """
27496 
 
27497 
  thrift_spec = (
27498 
    None, # 0
27499 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
27500 
  )
27501 
 
27502 
  def __init__(self, searchTerm=None,):
27503 
    self.searchTerm = searchTerm
27504 
 
27505 
  def read(self, iprot):
27506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27508 
      return
27509 
    iprot.readStructBegin()
27510 
    while True:
27511 
      (fname, ftype, fid) = iprot.readFieldBegin()
27512 
      if ftype == TType.STOP:
27513 
        break
27514 
      if fid == 1:
27515 
        if ftype == TType.LIST:
27516 
          self.searchTerm = []
27517 
          (_etype609, _size606) = iprot.readListBegin()
27518 
          for _i610 in xrange(_size606):
27519 
            _elem611 = iprot.readString();
27520 
            self.searchTerm.append(_elem611)
27521 
          iprot.readListEnd()
27522 
        else:
27523 
          iprot.skip(ftype)
27524 
      else:
27525 
        iprot.skip(ftype)
27526 
      iprot.readFieldEnd()
27527 
    iprot.readStructEnd()
27528 
 
27529 
  def write(self, oprot):
27530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27532 
      return
27533 
    oprot.writeStructBegin('getFlipkartSearchResultCount_args')
27534 
    if self.searchTerm is not None:
27535 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
27536 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
27537 
      for iter612 in self.searchTerm:
27538 
        oprot.writeString(iter612)
27539 
      oprot.writeListEnd()
27540 
      oprot.writeFieldEnd()
27541 
    oprot.writeFieldStop()
27542 
    oprot.writeStructEnd()
27543 
 
27544 
  def validate(self):
27545 
    return
27546 
 
27547 
 
27548 
  def __repr__(self):
27549 
    L = ['%s=%r' % (key, value)
27550 
      for key, value in self.__dict__.iteritems()]
27551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27552 
 
27553 
  def __eq__(self, other):
27554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27555 
 
27556 
  def __ne__(self, other):
27557 
    return not (self == other)
27558 
 
27559 
class getFlipkartSearchResultCount_result:
27560 
  """
27561 
  Attributes:
27562 
   - success
27563 
  """
27564 
 
27565 
  thrift_spec = (
27566 
    (0, TType.I64, 'success', None, None, ), # 0
27567 
  )
27568 
 
27569 
  def __init__(self, success=None,):
27570 
    self.success = success
27571 
 
27572 
  def read(self, iprot):
27573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27575 
      return
27576 
    iprot.readStructBegin()
27577 
    while True:
27578 
      (fname, ftype, fid) = iprot.readFieldBegin()
27579 
      if ftype == TType.STOP:
27580 
        break
27581 
      if fid == 0:
27582 
        if ftype == TType.I64:
27583 
          self.success = iprot.readI64();
27584 
        else:
27585 
          iprot.skip(ftype)
27586 
      else:
27587 
        iprot.skip(ftype)
27588 
      iprot.readFieldEnd()
27589 
    iprot.readStructEnd()
27590 
 
27591 
  def write(self, oprot):
27592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27594 
      return
27595 
    oprot.writeStructBegin('getFlipkartSearchResultCount_result')
27596 
    if self.success is not None:
27597 
      oprot.writeFieldBegin('success', TType.I64, 0)
27598 
      oprot.writeI64(self.success)
27599 
      oprot.writeFieldEnd()
27600 
    oprot.writeFieldStop()
27601 
    oprot.writeStructEnd()
27602 
 
27603 
  def validate(self):
27604 
    return
27605 
 
27606 
 
27607 
  def __repr__(self):
27608 
    L = ['%s=%r' % (key, value)
27609 
      for key, value in self.__dict__.iteritems()]
27610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27611 
 
27612 
  def __eq__(self, other):
27613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27614 
 
27615 
  def __ne__(self, other):
27616 
    return not (self == other)
27617 
 
27618 
class getAllFkItems_args:
27619 
 
27620 
  thrift_spec = (
27621 
  )
27622 
 
27623 
  def read(self, iprot):
27624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27626 
      return
27627 
    iprot.readStructBegin()
27628 
    while True:
27629 
      (fname, ftype, fid) = iprot.readFieldBegin()
27630 
      if ftype == TType.STOP:
27631 
        break
27632 
      else:
27633 
        iprot.skip(ftype)
27634 
      iprot.readFieldEnd()
27635 
    iprot.readStructEnd()
27636 
 
27637 
  def write(self, oprot):
27638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27640 
      return
27641 
    oprot.writeStructBegin('getAllFkItems_args')
27642 
    oprot.writeFieldStop()
27643 
    oprot.writeStructEnd()
27644 
 
27645 
  def validate(self):
27646 
    return
27647 
 
27648 
 
27649 
  def __repr__(self):
27650 
    L = ['%s=%r' % (key, value)
27651 
      for key, value in self.__dict__.iteritems()]
27652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27653 
 
27654 
  def __eq__(self, other):
27655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27656 
 
27657 
  def __ne__(self, other):
27658 
    return not (self == other)
27659 
 
27660 
class getAllFkItems_result:
27661 
  """
27662 
  Attributes:
27663 
   - success
27664 
  """
27665 
 
27666 
  thrift_spec = (
27667 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27668 
  )
27669 
 
27670 
  def __init__(self, success=None,):
27671 
    self.success = success
27672 
 
27673 
  def read(self, iprot):
27674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27676 
      return
27677 
    iprot.readStructBegin()
27678 
    while True:
27679 
      (fname, ftype, fid) = iprot.readFieldBegin()
27680 
      if ftype == TType.STOP:
27681 
        break
27682 
      if fid == 0:
27683 
        if ftype == TType.LIST:
27684 
          self.success = []
27685 
          (_etype616, _size613) = iprot.readListBegin()
27686 
          for _i617 in xrange(_size613):
27687 
            _elem618 = FlipkartItemDetails()
27688 
            _elem618.read(iprot)
27689 
            self.success.append(_elem618)
27690 
          iprot.readListEnd()
27691 
        else:
27692 
          iprot.skip(ftype)
27693 
      else:
27694 
        iprot.skip(ftype)
27695 
      iprot.readFieldEnd()
27696 
    iprot.readStructEnd()
27697 
 
27698 
  def write(self, oprot):
27699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27701 
      return
27702 
    oprot.writeStructBegin('getAllFkItems_result')
27703 
    if self.success is not None:
27704 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27705 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27706 
      for iter619 in self.success:
27707 
        iter619.write(oprot)
27708 
      oprot.writeListEnd()
27709 
      oprot.writeFieldEnd()
27710 
    oprot.writeFieldStop()
27711 
    oprot.writeStructEnd()
27712 
 
27713 
  def validate(self):
27714 
    return
27715 
 
27716 
 
27717 
  def __repr__(self):
27718 
    L = ['%s=%r' % (key, value)
27719 
      for key, value in self.__dict__.iteritems()]
27720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27721 
 
27722 
  def __eq__(self, other):
27723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27724 
 
27725 
  def __ne__(self, other):
27726 
    return not (self == other)
10140 vikram.rag 27727 
 
27728 
class getFlipkartItemBySkyAtFlipkart_args:
27729 
  """
27730 
  Attributes:
27731 
   - sku
27732 
  """
27733 
 
11531 vikram.rag 27734 
  thrift_spec = None
10140 vikram.rag 27735 
  def __init__(self, sku=None,):
27736 
    self.sku = sku
27737 
 
27738 
  def read(self, iprot):
27739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27741 
      return
27742 
    iprot.readStructBegin()
27743 
    while True:
27744 
      (fname, ftype, fid) = iprot.readFieldBegin()
27745 
      if ftype == TType.STOP:
27746 
        break
11531 vikram.rag 27747 
      if fid == -1:
10140 vikram.rag 27748 
        if ftype == TType.STRING:
27749 
          self.sku = iprot.readString();
27750 
        else:
27751 
          iprot.skip(ftype)
27752 
      else:
27753 
        iprot.skip(ftype)
27754 
      iprot.readFieldEnd()
27755 
    iprot.readStructEnd()
27756 
 
27757 
  def write(self, oprot):
27758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27760 
      return
27761 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_args')
27762 
    if self.sku is not None:
11531 vikram.rag 27763 
      oprot.writeFieldBegin('sku', TType.STRING, -1)
10140 vikram.rag 27764 
      oprot.writeString(self.sku)
27765 
      oprot.writeFieldEnd()
27766 
    oprot.writeFieldStop()
27767 
    oprot.writeStructEnd()
27768 
 
27769 
  def validate(self):
27770 
    return
27771 
 
27772 
 
27773 
  def __repr__(self):
27774 
    L = ['%s=%r' % (key, value)
27775 
      for key, value in self.__dict__.iteritems()]
27776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27777 
 
27778 
  def __eq__(self, other):
27779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27780 
 
27781 
  def __ne__(self, other):
27782 
    return not (self == other)
27783 
 
27784 
class getFlipkartItemBySkyAtFlipkart_result:
27785 
  """
27786 
  Attributes:
27787 
   - success
27788 
  """
27789 
 
27790 
  thrift_spec = (
27791 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
27792 
  )
27793 
 
27794 
  def __init__(self, success=None,):
27795 
    self.success = success
27796 
 
27797 
  def read(self, iprot):
27798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27800 
      return
27801 
    iprot.readStructBegin()
27802 
    while True:
27803 
      (fname, ftype, fid) = iprot.readFieldBegin()
27804 
      if ftype == TType.STOP:
27805 
        break
27806 
      if fid == 0:
27807 
        if ftype == TType.STRUCT:
27808 
          self.success = FlipkartItem()
27809 
          self.success.read(iprot)
27810 
        else:
27811 
          iprot.skip(ftype)
27812 
      else:
27813 
        iprot.skip(ftype)
27814 
      iprot.readFieldEnd()
27815 
    iprot.readStructEnd()
27816 
 
27817 
  def write(self, oprot):
27818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27820 
      return
27821 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_result')
27822 
    if self.success is not None:
27823 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27824 
      self.success.write(oprot)
27825 
      oprot.writeFieldEnd()
27826 
    oprot.writeFieldStop()
27827 
    oprot.writeStructEnd()
27828 
 
27829 
  def validate(self):
27830 
    return
27831 
 
27832 
 
27833 
  def __repr__(self):
27834 
    L = ['%s=%r' % (key, value)
27835 
      for key, value in self.__dict__.iteritems()]
27836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27837 
 
27838 
  def __eq__(self, other):
27839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27840 
 
27841 
  def __ne__(self, other):
27842 
    return not (self == other)
10909 vikram.rag 27843 
 
11015 kshitij.so 27844 
class getMarketplaceHistory_args:
27845 
  """
27846 
  Attributes:
27847 
   - source
27848 
   - offset
27849 
   - itemId
27850 
  """
10909 vikram.rag 27851 
 
27852 
  thrift_spec = (
11015 kshitij.so 27853 
    None, # 0
27854 
    (1, TType.I64, 'source', None, None, ), # 1
27855 
    (2, TType.I64, 'offset', None, None, ), # 2
27856 
    (3, TType.I64, 'itemId', None, None, ), # 3
10909 vikram.rag 27857 
  )
27858 
 
11015 kshitij.so 27859 
  def __init__(self, source=None, offset=None, itemId=None,):
27860 
    self.source = source
27861 
    self.offset = offset
27862 
    self.itemId = itemId
27863 
 
10909 vikram.rag 27864 
  def read(self, iprot):
27865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27867 
      return
27868 
    iprot.readStructBegin()
27869 
    while True:
27870 
      (fname, ftype, fid) = iprot.readFieldBegin()
27871 
      if ftype == TType.STOP:
27872 
        break
11015 kshitij.so 27873 
      if fid == 1:
27874 
        if ftype == TType.I64:
27875 
          self.source = iprot.readI64();
27876 
        else:
27877 
          iprot.skip(ftype)
27878 
      elif fid == 2:
27879 
        if ftype == TType.I64:
27880 
          self.offset = iprot.readI64();
27881 
        else:
27882 
          iprot.skip(ftype)
27883 
      elif fid == 3:
27884 
        if ftype == TType.I64:
27885 
          self.itemId = iprot.readI64();
27886 
        else:
27887 
          iprot.skip(ftype)
10909 vikram.rag 27888 
      else:
27889 
        iprot.skip(ftype)
27890 
      iprot.readFieldEnd()
27891 
    iprot.readStructEnd()
27892 
 
27893 
  def write(self, oprot):
27894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27896 
      return
11015 kshitij.so 27897 
    oprot.writeStructBegin('getMarketplaceHistory_args')
27898 
    if self.source is not None:
27899 
      oprot.writeFieldBegin('source', TType.I64, 1)
27900 
      oprot.writeI64(self.source)
27901 
      oprot.writeFieldEnd()
27902 
    if self.offset is not None:
27903 
      oprot.writeFieldBegin('offset', TType.I64, 2)
27904 
      oprot.writeI64(self.offset)
27905 
      oprot.writeFieldEnd()
27906 
    if self.itemId is not None:
27907 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
27908 
      oprot.writeI64(self.itemId)
27909 
      oprot.writeFieldEnd()
10909 vikram.rag 27910 
    oprot.writeFieldStop()
27911 
    oprot.writeStructEnd()
27912 
 
27913 
  def validate(self):
27914 
    return
27915 
 
27916 
 
27917 
  def __repr__(self):
27918 
    L = ['%s=%r' % (key, value)
27919 
      for key, value in self.__dict__.iteritems()]
27920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27921 
 
27922 
  def __eq__(self, other):
27923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27924 
 
27925 
  def __ne__(self, other):
27926 
    return not (self == other)
27927 
 
11015 kshitij.so 27928 
class getMarketplaceHistory_result:
10909 vikram.rag 27929 
  """
27930 
  Attributes:
27931 
   - success
27932 
  """
27933 
 
27934 
  thrift_spec = (
11015 kshitij.so 27935 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
10909 vikram.rag 27936 
  )
27937 
 
27938 
  def __init__(self, success=None,):
27939 
    self.success = success
27940 
 
27941 
  def read(self, iprot):
27942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27944 
      return
27945 
    iprot.readStructBegin()
27946 
    while True:
27947 
      (fname, ftype, fid) = iprot.readFieldBegin()
27948 
      if ftype == TType.STOP:
27949 
        break
27950 
      if fid == 0:
27951 
        if ftype == TType.LIST:
27952 
          self.success = []
27953 
          (_etype623, _size620) = iprot.readListBegin()
27954 
          for _i624 in xrange(_size620):
11015 kshitij.so 27955 
            _elem625 = MarketplaceHistory()
10909 vikram.rag 27956 
            _elem625.read(iprot)
27957 
            self.success.append(_elem625)
27958 
          iprot.readListEnd()
27959 
        else:
27960 
          iprot.skip(ftype)
27961 
      else:
27962 
        iprot.skip(ftype)
27963 
      iprot.readFieldEnd()
27964 
    iprot.readStructEnd()
27965 
 
27966 
  def write(self, oprot):
27967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27969 
      return
11015 kshitij.so 27970 
    oprot.writeStructBegin('getMarketplaceHistory_result')
10909 vikram.rag 27971 
    if self.success is not None:
27972 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27973 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27974 
      for iter626 in self.success:
27975 
        iter626.write(oprot)
27976 
      oprot.writeListEnd()
27977 
      oprot.writeFieldEnd()
27978 
    oprot.writeFieldStop()
27979 
    oprot.writeStructEnd()
27980 
 
27981 
  def validate(self):
27982 
    return
27983 
 
27984 
 
27985 
  def __repr__(self):
27986 
    L = ['%s=%r' % (key, value)
27987 
      for key, value in self.__dict__.iteritems()]
27988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27989 
 
27990 
  def __eq__(self, other):
27991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27992 
 
27993 
  def __ne__(self, other):
27994 
    return not (self == other)
10924 vikram.rag 27995 
 
11015 kshitij.so 27996 
class getAllFbbListedItems_args:
10924 vikram.rag 27997 
 
27998 
  thrift_spec = (
27999 
  )
28000 
 
28001 
  def read(self, iprot):
28002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28004 
      return
28005 
    iprot.readStructBegin()
28006 
    while True:
28007 
      (fname, ftype, fid) = iprot.readFieldBegin()
28008 
      if ftype == TType.STOP:
28009 
        break
28010 
      else:
28011 
        iprot.skip(ftype)
28012 
      iprot.readFieldEnd()
28013 
    iprot.readStructEnd()
28014 
 
28015 
  def write(self, oprot):
28016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28018 
      return
11015 kshitij.so 28019 
    oprot.writeStructBegin('getAllFbbListedItems_args')
10924 vikram.rag 28020 
    oprot.writeFieldStop()
28021 
    oprot.writeStructEnd()
28022 
 
28023 
  def validate(self):
28024 
    return
28025 
 
28026 
 
28027 
  def __repr__(self):
28028 
    L = ['%s=%r' % (key, value)
28029 
      for key, value in self.__dict__.iteritems()]
28030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28031 
 
28032 
  def __eq__(self, other):
28033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28034 
 
28035 
  def __ne__(self, other):
28036 
    return not (self == other)
28037 
 
11015 kshitij.so 28038 
class getAllFbbListedItems_result:
10924 vikram.rag 28039 
  """
28040 
  Attributes:
28041 
   - success
28042 
  """
28043 
 
28044 
  thrift_spec = (
28045 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
28046 
  )
28047 
 
28048 
  def __init__(self, success=None,):
28049 
    self.success = success
28050 
 
28051 
  def read(self, iprot):
28052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28054 
      return
28055 
    iprot.readStructBegin()
28056 
    while True:
28057 
      (fname, ftype, fid) = iprot.readFieldBegin()
28058 
      if ftype == TType.STOP:
28059 
        break
28060 
      if fid == 0:
28061 
        if ftype == TType.LIST:
28062 
          self.success = []
28063 
          (_etype630, _size627) = iprot.readListBegin()
28064 
          for _i631 in xrange(_size627):
28065 
            _elem632 = Amazonlisted()
28066 
            _elem632.read(iprot)
28067 
            self.success.append(_elem632)
28068 
          iprot.readListEnd()
28069 
        else:
28070 
          iprot.skip(ftype)
28071 
      else:
28072 
        iprot.skip(ftype)
28073 
      iprot.readFieldEnd()
28074 
    iprot.readStructEnd()
28075 
 
28076 
  def write(self, oprot):
28077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28079 
      return
11015 kshitij.so 28080 
    oprot.writeStructBegin('getAllFbbListedItems_result')
10924 vikram.rag 28081 
    if self.success is not None:
28082 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28083 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28084 
      for iter633 in self.success:
28085 
        iter633.write(oprot)
28086 
      oprot.writeListEnd()
28087 
      oprot.writeFieldEnd()
28088 
    oprot.writeFieldStop()
28089 
    oprot.writeStructEnd()
28090 
 
28091 
  def validate(self):
28092 
    return
28093 
 
28094 
 
28095 
  def __repr__(self):
28096 
    L = ['%s=%r' % (key, value)
28097 
      for key, value in self.__dict__.iteritems()]
28098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28099 
 
28100 
  def __eq__(self, other):
28101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28102 
 
28103 
  def __ne__(self, other):
28104 
    return not (self == other)
11015 kshitij.so 28105 
 
28106 
class getAllFbbPricingItems_args:
28107 
 
28108 
  thrift_spec = (
28109 
  )
28110 
 
28111 
  def read(self, iprot):
28112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28114 
      return
28115 
    iprot.readStructBegin()
28116 
    while True:
28117 
      (fname, ftype, fid) = iprot.readFieldBegin()
28118 
      if ftype == TType.STOP:
28119 
        break
28120 
      else:
28121 
        iprot.skip(ftype)
28122 
      iprot.readFieldEnd()
28123 
    iprot.readStructEnd()
28124 
 
28125 
  def write(self, oprot):
28126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28128 
      return
28129 
    oprot.writeStructBegin('getAllFbbPricingItems_args')
28130 
    oprot.writeFieldStop()
28131 
    oprot.writeStructEnd()
28132 
 
28133 
  def validate(self):
28134 
    return
28135 
 
28136 
 
28137 
  def __repr__(self):
28138 
    L = ['%s=%r' % (key, value)
28139 
      for key, value in self.__dict__.iteritems()]
28140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28141 
 
28142 
  def __eq__(self, other):
28143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28144 
 
28145 
  def __ne__(self, other):
28146 
    return not (self == other)
28147 
 
28148 
class getAllFbbPricingItems_result:
28149 
  """
28150 
  Attributes:
28151 
   - success
28152 
  """
28153 
 
28154 
  thrift_spec = (
28155 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
28156 
  )
28157 
 
28158 
  def __init__(self, success=None,):
28159 
    self.success = success
28160 
 
28161 
  def read(self, iprot):
28162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28164 
      return
28165 
    iprot.readStructBegin()
28166 
    while True:
28167 
      (fname, ftype, fid) = iprot.readFieldBegin()
28168 
      if ftype == TType.STOP:
28169 
        break
28170 
      if fid == 0:
28171 
        if ftype == TType.LIST:
28172 
          self.success = []
28173 
          (_etype637, _size634) = iprot.readListBegin()
28174 
          for _i638 in xrange(_size634):
28175 
            _elem639 = Amazonlisted()
28176 
            _elem639.read(iprot)
28177 
            self.success.append(_elem639)
28178 
          iprot.readListEnd()
28179 
        else:
28180 
          iprot.skip(ftype)
28181 
      else:
28182 
        iprot.skip(ftype)
28183 
      iprot.readFieldEnd()
28184 
    iprot.readStructEnd()
28185 
 
28186 
  def write(self, oprot):
28187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28189 
      return
28190 
    oprot.writeStructBegin('getAllFbbPricingItems_result')
28191 
    if self.success is not None:
28192 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28193 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28194 
      for iter640 in self.success:
28195 
        iter640.write(oprot)
28196 
      oprot.writeListEnd()
28197 
      oprot.writeFieldEnd()
28198 
    oprot.writeFieldStop()
28199 
    oprot.writeStructEnd()
28200 
 
28201 
  def validate(self):
28202 
    return
28203 
 
28204 
 
28205 
  def __repr__(self):
28206 
    L = ['%s=%r' % (key, value)
28207 
      for key, value in self.__dict__.iteritems()]
28208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28209 
 
28210 
  def __eq__(self, other):
28211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28212 
 
28213 
  def __ne__(self, other):
28214 
    return not (self == other)
28215 
 
28216 
class getCountForMarketplaceHistory_args:
28217 
  """
28218 
  Attributes:
28219 
   - source
28220 
   - itemId
28221 
  """
28222 
 
28223 
  thrift_spec = (
28224 
    None, # 0
28225 
    (1, TType.I64, 'source', None, None, ), # 1
28226 
    (2, TType.I64, 'itemId', None, None, ), # 2
28227 
  )
28228 
 
28229 
  def __init__(self, source=None, itemId=None,):
28230 
    self.source = source
28231 
    self.itemId = itemId
28232 
 
28233 
  def read(self, iprot):
28234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28236 
      return
28237 
    iprot.readStructBegin()
28238 
    while True:
28239 
      (fname, ftype, fid) = iprot.readFieldBegin()
28240 
      if ftype == TType.STOP:
28241 
        break
28242 
      if fid == 1:
28243 
        if ftype == TType.I64:
28244 
          self.source = iprot.readI64();
28245 
        else:
28246 
          iprot.skip(ftype)
28247 
      elif fid == 2:
28248 
        if ftype == TType.I64:
28249 
          self.itemId = iprot.readI64();
28250 
        else:
28251 
          iprot.skip(ftype)
28252 
      else:
28253 
        iprot.skip(ftype)
28254 
      iprot.readFieldEnd()
28255 
    iprot.readStructEnd()
28256 
 
28257 
  def write(self, oprot):
28258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28260 
      return
28261 
    oprot.writeStructBegin('getCountForMarketplaceHistory_args')
28262 
    if self.source is not None:
28263 
      oprot.writeFieldBegin('source', TType.I64, 1)
28264 
      oprot.writeI64(self.source)
28265 
      oprot.writeFieldEnd()
28266 
    if self.itemId is not None:
28267 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
28268 
      oprot.writeI64(self.itemId)
28269 
      oprot.writeFieldEnd()
28270 
    oprot.writeFieldStop()
28271 
    oprot.writeStructEnd()
28272 
 
28273 
  def validate(self):
28274 
    return
28275 
 
28276 
 
28277 
  def __repr__(self):
28278 
    L = ['%s=%r' % (key, value)
28279 
      for key, value in self.__dict__.iteritems()]
28280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28281 
 
28282 
  def __eq__(self, other):
28283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28284 
 
28285 
  def __ne__(self, other):
28286 
    return not (self == other)
28287 
 
28288 
class getCountForMarketplaceHistory_result:
28289 
  """
28290 
  Attributes:
28291 
   - success
28292 
  """
28293 
 
28294 
  thrift_spec = (
28295 
    (0, TType.I64, 'success', None, None, ), # 0
28296 
  )
28297 
 
28298 
  def __init__(self, success=None,):
28299 
    self.success = success
28300 
 
28301 
  def read(self, iprot):
28302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28304 
      return
28305 
    iprot.readStructBegin()
28306 
    while True:
28307 
      (fname, ftype, fid) = iprot.readFieldBegin()
28308 
      if ftype == TType.STOP:
28309 
        break
28310 
      if fid == 0:
28311 
        if ftype == TType.I64:
28312 
          self.success = iprot.readI64();
28313 
        else:
28314 
          iprot.skip(ftype)
28315 
      else:
28316 
        iprot.skip(ftype)
28317 
      iprot.readFieldEnd()
28318 
    iprot.readStructEnd()
28319 
 
28320 
  def write(self, oprot):
28321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28323 
      return
28324 
    oprot.writeStructBegin('getCountForMarketplaceHistory_result')
28325 
    if self.success is not None:
28326 
      oprot.writeFieldBegin('success', TType.I64, 0)
28327 
      oprot.writeI64(self.success)
28328 
      oprot.writeFieldEnd()
28329 
    oprot.writeFieldStop()
28330 
    oprot.writeStructEnd()
28331 
 
28332 
  def validate(self):
28333 
    return
28334 
 
28335 
 
28336 
  def __repr__(self):
28337 
    L = ['%s=%r' % (key, value)
28338 
      for key, value in self.__dict__.iteritems()]
28339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28340 
 
28341 
  def __eq__(self, other):
28342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28343 
 
28344 
  def __ne__(self, other):
28345 
    return not (self == other)
28346 
 
28347 
class getMarketplaceHistoryByDate_args:
28348 
  """
28349 
  Attributes:
28350 
   - source
28351 
   - startDate
28352 
   - endDate
28353 
   - offset
28354 
   - limit
28355 
   - itemId
28356 
  """
28357 
 
28358 
  thrift_spec = (
28359 
    None, # 0
28360 
    (1, TType.I64, 'source', None, None, ), # 1
28361 
    (2, TType.I64, 'startDate', None, None, ), # 2
28362 
    (3, TType.I64, 'endDate', None, None, ), # 3
28363 
    (4, TType.I64, 'offset', None, None, ), # 4
28364 
    (5, TType.I64, 'limit', None, None, ), # 5
28365 
    (6, TType.I64, 'itemId', None, None, ), # 6
28366 
  )
28367 
 
28368 
  def __init__(self, source=None, startDate=None, endDate=None, offset=None, limit=None, itemId=None,):
28369 
    self.source = source
28370 
    self.startDate = startDate
28371 
    self.endDate = endDate
28372 
    self.offset = offset
28373 
    self.limit = limit
28374 
    self.itemId = itemId
28375 
 
28376 
  def read(self, iprot):
28377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28379 
      return
28380 
    iprot.readStructBegin()
28381 
    while True:
28382 
      (fname, ftype, fid) = iprot.readFieldBegin()
28383 
      if ftype == TType.STOP:
28384 
        break
28385 
      if fid == 1:
28386 
        if ftype == TType.I64:
28387 
          self.source = iprot.readI64();
28388 
        else:
28389 
          iprot.skip(ftype)
28390 
      elif fid == 2:
28391 
        if ftype == TType.I64:
28392 
          self.startDate = iprot.readI64();
28393 
        else:
28394 
          iprot.skip(ftype)
28395 
      elif fid == 3:
28396 
        if ftype == TType.I64:
28397 
          self.endDate = iprot.readI64();
28398 
        else:
28399 
          iprot.skip(ftype)
28400 
      elif fid == 4:
28401 
        if ftype == TType.I64:
28402 
          self.offset = iprot.readI64();
28403 
        else:
28404 
          iprot.skip(ftype)
28405 
      elif fid == 5:
28406 
        if ftype == TType.I64:
28407 
          self.limit = iprot.readI64();
28408 
        else:
28409 
          iprot.skip(ftype)
28410 
      elif fid == 6:
28411 
        if ftype == TType.I64:
28412 
          self.itemId = iprot.readI64();
28413 
        else:
28414 
          iprot.skip(ftype)
28415 
      else:
28416 
        iprot.skip(ftype)
28417 
      iprot.readFieldEnd()
28418 
    iprot.readStructEnd()
28419 
 
28420 
  def write(self, oprot):
28421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28423 
      return
28424 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_args')
28425 
    if self.source is not None:
28426 
      oprot.writeFieldBegin('source', TType.I64, 1)
28427 
      oprot.writeI64(self.source)
28428 
      oprot.writeFieldEnd()
28429 
    if self.startDate is not None:
28430 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
28431 
      oprot.writeI64(self.startDate)
28432 
      oprot.writeFieldEnd()
28433 
    if self.endDate is not None:
28434 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
28435 
      oprot.writeI64(self.endDate)
28436 
      oprot.writeFieldEnd()
28437 
    if self.offset is not None:
28438 
      oprot.writeFieldBegin('offset', TType.I64, 4)
28439 
      oprot.writeI64(self.offset)
28440 
      oprot.writeFieldEnd()
28441 
    if self.limit is not None:
28442 
      oprot.writeFieldBegin('limit', TType.I64, 5)
28443 
      oprot.writeI64(self.limit)
28444 
      oprot.writeFieldEnd()
28445 
    if self.itemId is not None:
28446 
      oprot.writeFieldBegin('itemId', TType.I64, 6)
28447 
      oprot.writeI64(self.itemId)
28448 
      oprot.writeFieldEnd()
28449 
    oprot.writeFieldStop()
28450 
    oprot.writeStructEnd()
28451 
 
28452 
  def validate(self):
28453 
    return
28454 
 
28455 
 
28456 
  def __repr__(self):
28457 
    L = ['%s=%r' % (key, value)
28458 
      for key, value in self.__dict__.iteritems()]
28459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28460 
 
28461 
  def __eq__(self, other):
28462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28463 
 
28464 
  def __ne__(self, other):
28465 
    return not (self == other)
28466 
 
28467 
class getMarketplaceHistoryByDate_result:
28468 
  """
28469 
  Attributes:
28470 
   - success
28471 
  """
28472 
 
28473 
  thrift_spec = (
28474 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
28475 
  )
28476 
 
28477 
  def __init__(self, success=None,):
28478 
    self.success = success
28479 
 
28480 
  def read(self, iprot):
28481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28483 
      return
28484 
    iprot.readStructBegin()
28485 
    while True:
28486 
      (fname, ftype, fid) = iprot.readFieldBegin()
28487 
      if ftype == TType.STOP:
28488 
        break
28489 
      if fid == 0:
28490 
        if ftype == TType.LIST:
28491 
          self.success = []
28492 
          (_etype644, _size641) = iprot.readListBegin()
28493 
          for _i645 in xrange(_size641):
28494 
            _elem646 = MarketplaceHistory()
28495 
            _elem646.read(iprot)
28496 
            self.success.append(_elem646)
28497 
          iprot.readListEnd()
28498 
        else:
28499 
          iprot.skip(ftype)
28500 
      else:
28501 
        iprot.skip(ftype)
28502 
      iprot.readFieldEnd()
28503 
    iprot.readStructEnd()
28504 
 
28505 
  def write(self, oprot):
28506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28508 
      return
28509 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_result')
28510 
    if self.success is not None:
28511 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28512 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28513 
      for iter647 in self.success:
28514 
        iter647.write(oprot)
28515 
      oprot.writeListEnd()
28516 
      oprot.writeFieldEnd()
28517 
    oprot.writeFieldStop()
28518 
    oprot.writeStructEnd()
28519 
 
28520 
  def validate(self):
28521 
    return
28522 
 
28523 
 
28524 
  def __repr__(self):
28525 
    L = ['%s=%r' % (key, value)
28526 
      for key, value in self.__dict__.iteritems()]
28527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28528 
 
28529 
  def __eq__(self, other):
28530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28531 
 
28532 
  def __ne__(self, other):
28533 
    return not (self == other)
11531 vikram.rag 28534 
 
28535 
class getPrivateDealDetails_args:
28536 
  """
28537 
  Attributes:
28538 
   - item_id
28539 
  """
28540 
 
28541 
  thrift_spec = (
28542 
    None, # 0
28543 
    (1, TType.I64, 'item_id', None, None, ), # 1
28544 
  )
28545 
 
28546 
  def __init__(self, item_id=None,):
28547 
    self.item_id = item_id
28548 
 
28549 
  def read(self, iprot):
28550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28552 
      return
28553 
    iprot.readStructBegin()
28554 
    while True:
28555 
      (fname, ftype, fid) = iprot.readFieldBegin()
28556 
      if ftype == TType.STOP:
28557 
        break
28558 
      if fid == 1:
28559 
        if ftype == TType.I64:
28560 
          self.item_id = iprot.readI64();
28561 
        else:
28562 
          iprot.skip(ftype)
28563 
      else:
28564 
        iprot.skip(ftype)
28565 
      iprot.readFieldEnd()
28566 
    iprot.readStructEnd()
28567 
 
28568 
  def write(self, oprot):
28569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28571 
      return
28572 
    oprot.writeStructBegin('getPrivateDealDetails_args')
28573 
    if self.item_id is not None:
28574 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
28575 
      oprot.writeI64(self.item_id)
28576 
      oprot.writeFieldEnd()
28577 
    oprot.writeFieldStop()
28578 
    oprot.writeStructEnd()
28579 
 
28580 
  def validate(self):
28581 
    return
28582 
 
28583 
 
28584 
  def __repr__(self):
28585 
    L = ['%s=%r' % (key, value)
28586 
      for key, value in self.__dict__.iteritems()]
28587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28588 
 
28589 
  def __eq__(self, other):
28590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28591 
 
28592 
  def __ne__(self, other):
28593 
    return not (self == other)
28594 
 
28595 
class getPrivateDealDetails_result:
28596 
  """
28597 
  Attributes:
28598 
   - success
28599 
  """
28600 
 
28601 
  thrift_spec = (
28602 
    (0, TType.STRUCT, 'success', (PrivateDeal, PrivateDeal.thrift_spec), None, ), # 0
28603 
  )
28604 
 
28605 
  def __init__(self, success=None,):
28606 
    self.success = success
28607 
 
28608 
  def read(self, iprot):
28609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28611 
      return
28612 
    iprot.readStructBegin()
28613 
    while True:
28614 
      (fname, ftype, fid) = iprot.readFieldBegin()
28615 
      if ftype == TType.STOP:
28616 
        break
28617 
      if fid == 0:
28618 
        if ftype == TType.STRUCT:
28619 
          self.success = PrivateDeal()
28620 
          self.success.read(iprot)
28621 
        else:
28622 
          iprot.skip(ftype)
28623 
      else:
28624 
        iprot.skip(ftype)
28625 
      iprot.readFieldEnd()
28626 
    iprot.readStructEnd()
28627 
 
28628 
  def write(self, oprot):
28629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28631 
      return
28632 
    oprot.writeStructBegin('getPrivateDealDetails_result')
28633 
    if self.success is not None:
28634 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28635 
      self.success.write(oprot)
28636 
      oprot.writeFieldEnd()
28637 
    oprot.writeFieldStop()
28638 
    oprot.writeStructEnd()
28639 
 
28640 
  def validate(self):
28641 
    return
28642 
 
28643 
 
28644 
  def __repr__(self):
28645 
    L = ['%s=%r' % (key, value)
28646 
      for key, value in self.__dict__.iteritems()]
28647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28648 
 
28649 
  def __eq__(self, other):
28650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28651 
 
28652 
  def __ne__(self, other):
28653 
    return not (self == other)
28654 
 
28655 
class getPrivateDealItems_args:
28656 
  """
28657 
  Attributes:
28658 
   - offset
28659 
   - limit
28660 
  """
28661 
 
28662 
  thrift_spec = (
28663 
    None, # 0
28664 
    (1, TType.I64, 'offset', None, None, ), # 1
28665 
    (2, TType.I64, 'limit', None, None, ), # 2
28666 
  )
28667 
 
28668 
  def __init__(self, offset=None, limit=None,):
28669 
    self.offset = offset
28670 
    self.limit = limit
28671 
 
28672 
  def read(self, iprot):
28673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28675 
      return
28676 
    iprot.readStructBegin()
28677 
    while True:
28678 
      (fname, ftype, fid) = iprot.readFieldBegin()
28679 
      if ftype == TType.STOP:
28680 
        break
28681 
      if fid == 1:
28682 
        if ftype == TType.I64:
28683 
          self.offset = iprot.readI64();
28684 
        else:
28685 
          iprot.skip(ftype)
28686 
      elif fid == 2:
28687 
        if ftype == TType.I64:
28688 
          self.limit = iprot.readI64();
28689 
        else:
28690 
          iprot.skip(ftype)
28691 
      else:
28692 
        iprot.skip(ftype)
28693 
      iprot.readFieldEnd()
28694 
    iprot.readStructEnd()
28695 
 
28696 
  def write(self, oprot):
28697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28699 
      return
28700 
    oprot.writeStructBegin('getPrivateDealItems_args')
28701 
    if self.offset is not None:
28702 
      oprot.writeFieldBegin('offset', TType.I64, 1)
28703 
      oprot.writeI64(self.offset)
28704 
      oprot.writeFieldEnd()
28705 
    if self.limit is not None:
28706 
      oprot.writeFieldBegin('limit', TType.I64, 2)
28707 
      oprot.writeI64(self.limit)
28708 
      oprot.writeFieldEnd()
28709 
    oprot.writeFieldStop()
28710 
    oprot.writeStructEnd()
28711 
 
28712 
  def validate(self):
28713 
    return
28714 
 
28715 
 
28716 
  def __repr__(self):
28717 
    L = ['%s=%r' % (key, value)
28718 
      for key, value in self.__dict__.iteritems()]
28719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28720 
 
28721 
  def __eq__(self, other):
28722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28723 
 
28724 
  def __ne__(self, other):
28725 
    return not (self == other)
28726 
 
28727 
class getPrivateDealItems_result:
28728 
  """
28729 
  Attributes:
28730 
   - success
28731 
  """
28732 
 
28733 
  thrift_spec = (
28734 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
28735 
  )
28736 
 
28737 
  def __init__(self, success=None,):
28738 
    self.success = success
28739 
 
28740 
  def read(self, iprot):
28741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28743 
      return
28744 
    iprot.readStructBegin()
28745 
    while True:
28746 
      (fname, ftype, fid) = iprot.readFieldBegin()
28747 
      if ftype == TType.STOP:
28748 
        break
28749 
      if fid == 0:
28750 
        if ftype == TType.LIST:
28751 
          self.success = []
28752 
          (_etype651, _size648) = iprot.readListBegin()
28753 
          for _i652 in xrange(_size648):
28754 
            _elem653 = Item()
28755 
            _elem653.read(iprot)
28756 
            self.success.append(_elem653)
28757 
          iprot.readListEnd()
28758 
        else:
28759 
          iprot.skip(ftype)
28760 
      else:
28761 
        iprot.skip(ftype)
28762 
      iprot.readFieldEnd()
28763 
    iprot.readStructEnd()
28764 
 
28765 
  def write(self, oprot):
28766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28768 
      return
28769 
    oprot.writeStructBegin('getPrivateDealItems_result')
28770 
    if self.success is not None:
28771 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28772 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28773 
      for iter654 in self.success:
28774 
        iter654.write(oprot)
28775 
      oprot.writeListEnd()
28776 
      oprot.writeFieldEnd()
28777 
    oprot.writeFieldStop()
28778 
    oprot.writeStructEnd()
28779 
 
28780 
  def validate(self):
28781 
    return
28782 
 
28783 
 
28784 
  def __repr__(self):
28785 
    L = ['%s=%r' % (key, value)
28786 
      for key, value in self.__dict__.iteritems()]
28787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28788 
 
28789 
  def __eq__(self, other):
28790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28791 
 
28792 
  def __ne__(self, other):
28793 
    return not (self == other)
28794 
 
11592 amit.gupta 28795 
class getAllActivePrivateDeals_args:
28796 
 
28797 
  thrift_spec = (
28798 
  )
28799 
 
28800 
  def read(self, iprot):
28801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28803 
      return
28804 
    iprot.readStructBegin()
28805 
    while True:
28806 
      (fname, ftype, fid) = iprot.readFieldBegin()
28807 
      if ftype == TType.STOP:
28808 
        break
28809 
      else:
28810 
        iprot.skip(ftype)
28811 
      iprot.readFieldEnd()
28812 
    iprot.readStructEnd()
28813 
 
28814 
  def write(self, oprot):
28815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28817 
      return
28818 
    oprot.writeStructBegin('getAllActivePrivateDeals_args')
28819 
    oprot.writeFieldStop()
28820 
    oprot.writeStructEnd()
28821 
 
28822 
  def validate(self):
28823 
    return
28824 
 
28825 
 
28826 
  def __repr__(self):
28827 
    L = ['%s=%r' % (key, value)
28828 
      for key, value in self.__dict__.iteritems()]
28829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28830 
 
28831 
  def __eq__(self, other):
28832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28833 
 
28834 
  def __ne__(self, other):
28835 
    return not (self == other)
28836 
 
28837 
class getAllActivePrivateDeals_result:
28838 
  """
28839 
  Attributes:
28840 
   - success
28841 
  """
28842 
 
28843 
  thrift_spec = (
28844 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(PrivateDeal, PrivateDeal.thrift_spec)), None, ), # 0
28845 
  )
28846 
 
28847 
  def __init__(self, success=None,):
28848 
    self.success = success
28849 
 
28850 
  def read(self, iprot):
28851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28853 
      return
28854 
    iprot.readStructBegin()
28855 
    while True:
28856 
      (fname, ftype, fid) = iprot.readFieldBegin()
28857 
      if ftype == TType.STOP:
28858 
        break
28859 
      if fid == 0:
28860 
        if ftype == TType.MAP:
28861 
          self.success = {}
28862 
          (_ktype656, _vtype657, _size655 ) = iprot.readMapBegin()
28863 
          for _i659 in xrange(_size655):
28864 
            _key660 = iprot.readI64();
28865 
            _val661 = PrivateDeal()
28866 
            _val661.read(iprot)
28867 
            self.success[_key660] = _val661
28868 
          iprot.readMapEnd()
28869 
        else:
28870 
          iprot.skip(ftype)
28871 
      else:
28872 
        iprot.skip(ftype)
28873 
      iprot.readFieldEnd()
28874 
    iprot.readStructEnd()
28875 
 
28876 
  def write(self, oprot):
28877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28879 
      return
28880 
    oprot.writeStructBegin('getAllActivePrivateDeals_result')
28881 
    if self.success is not None:
28882 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28883 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
28884 
      for kiter662,viter663 in self.success.items():
28885 
        oprot.writeI64(kiter662)
28886 
        viter663.write(oprot)
28887 
      oprot.writeMapEnd()
28888 
      oprot.writeFieldEnd()
28889 
    oprot.writeFieldStop()
28890 
    oprot.writeStructEnd()
28891 
 
28892 
  def validate(self):
28893 
    return
28894 
 
28895 
 
28896 
  def __repr__(self):
28897 
    L = ['%s=%r' % (key, value)
28898 
      for key, value in self.__dict__.iteritems()]
28899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28900 
 
28901 
  def __eq__(self, other):
28902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28903 
 
28904 
  def __ne__(self, other):
28905 
    return not (self == other)
28906 
 
11531 vikram.rag 28907 
class addOrUpdatePrivateDeal_args:
28908 
  """
28909 
  Attributes:
28910 
   - privateDeal
28911 
  """
28912 
 
28913 
  thrift_spec = (
28914 
    None, # 0
28915 
    (1, TType.STRUCT, 'privateDeal', (PrivateDeal, PrivateDeal.thrift_spec), None, ), # 1
28916 
  )
28917 
 
28918 
  def __init__(self, privateDeal=None,):
28919 
    self.privateDeal = privateDeal
28920 
 
28921 
  def read(self, iprot):
28922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28924 
      return
28925 
    iprot.readStructBegin()
28926 
    while True:
28927 
      (fname, ftype, fid) = iprot.readFieldBegin()
28928 
      if ftype == TType.STOP:
28929 
        break
28930 
      if fid == 1:
28931 
        if ftype == TType.STRUCT:
28932 
          self.privateDeal = PrivateDeal()
28933 
          self.privateDeal.read(iprot)
28934 
        else:
28935 
          iprot.skip(ftype)
28936 
      else:
28937 
        iprot.skip(ftype)
28938 
      iprot.readFieldEnd()
28939 
    iprot.readStructEnd()
28940 
 
28941 
  def write(self, oprot):
28942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28944 
      return
28945 
    oprot.writeStructBegin('addOrUpdatePrivateDeal_args')
28946 
    if self.privateDeal is not None:
28947 
      oprot.writeFieldBegin('privateDeal', TType.STRUCT, 1)
28948 
      self.privateDeal.write(oprot)
28949 
      oprot.writeFieldEnd()
28950 
    oprot.writeFieldStop()
28951 
    oprot.writeStructEnd()
28952 
 
28953 
  def validate(self):
28954 
    return
28955 
 
28956 
 
28957 
  def __repr__(self):
28958 
    L = ['%s=%r' % (key, value)
28959 
      for key, value in self.__dict__.iteritems()]
28960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28961 
 
28962 
  def __eq__(self, other):
28963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28964 
 
28965 
  def __ne__(self, other):
28966 
    return not (self == other)
28967 
 
28968 
class addOrUpdatePrivateDeal_result:
28969 
  """
28970 
  Attributes:
28971 
   - success
28972 
  """
28973 
 
28974 
  thrift_spec = (
28975 
    (0, TType.BOOL, 'success', None, None, ), # 0
28976 
  )
28977 
 
28978 
  def __init__(self, success=None,):
28979 
    self.success = success
28980 
 
28981 
  def read(self, iprot):
28982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28984 
      return
28985 
    iprot.readStructBegin()
28986 
    while True:
28987 
      (fname, ftype, fid) = iprot.readFieldBegin()
28988 
      if ftype == TType.STOP:
28989 
        break
28990 
      if fid == 0:
28991 
        if ftype == TType.BOOL:
28992 
          self.success = iprot.readBool();
28993 
        else:
28994 
          iprot.skip(ftype)
28995 
      else:
28996 
        iprot.skip(ftype)
28997 
      iprot.readFieldEnd()
28998 
    iprot.readStructEnd()
28999 
 
29000 
  def write(self, oprot):
29001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29003 
      return
29004 
    oprot.writeStructBegin('addOrUpdatePrivateDeal_result')
29005 
    if self.success is not None:
29006 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29007 
      oprot.writeBool(self.success)
29008 
      oprot.writeFieldEnd()
29009 
    oprot.writeFieldStop()
29010 
    oprot.writeStructEnd()
29011 
 
29012 
  def validate(self):
29013 
    return
29014 
 
29015 
 
29016 
  def __repr__(self):
29017 
    L = ['%s=%r' % (key, value)
29018 
      for key, value in self.__dict__.iteritems()]
29019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29020 
 
29021 
  def __eq__(self, other):
29022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29023 
 
29024 
  def __ne__(self, other):
29025 
    return not (self == other)