Subversion Repositories SmartDukaan

Rev

Rev 10097 | Rev 10909 | 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 
 
10140 vikram.rag 1114 
 
5944 mandeep.dh 1115 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1116 
  def __init__(self, iprot, oprot=None):
1117 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1118 
 
1119 
  def addItem(self, item):
1120 
    """
1121 
    Availability and inventory attributes
1122 
 
1123 
    Parameters:
1124 
     - item
1125 
    """
1126 
    self.send_addItem(item)
1127 
    return self.recv_addItem()
1128 
 
1129 
  def send_addItem(self, item):
1130 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1131 
    args = addItem_args()
1132 
    args.item = item
1133 
    args.write(self._oprot)
1134 
    self._oprot.writeMessageEnd()
1135 
    self._oprot.trans.flush()
1136 
 
1137 
  def recv_addItem(self, ):
1138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1139 
    if mtype == TMessageType.EXCEPTION:
1140 
      x = TApplicationException()
1141 
      x.read(self._iprot)
1142 
      self._iprot.readMessageEnd()
1143 
      raise x
1144 
    result = addItem_result()
1145 
    result.read(self._iprot)
1146 
    self._iprot.readMessageEnd()
1147 
    if result.success is not None:
1148 
      return result.success
1149 
    if result.cex is not None:
1150 
      raise result.cex
1151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1152 
 
1153 
  def updateItem(self, item):
1154 
    """
1155 
    Parameters:
1156 
     - item
1157 
    """
1158 
    self.send_updateItem(item)
1159 
    return self.recv_updateItem()
1160 
 
1161 
  def send_updateItem(self, item):
1162 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1163 
    args = updateItem_args()
1164 
    args.item = item
1165 
    args.write(self._oprot)
1166 
    self._oprot.writeMessageEnd()
1167 
    self._oprot.trans.flush()
1168 
 
1169 
  def recv_updateItem(self, ):
1170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1171 
    if mtype == TMessageType.EXCEPTION:
1172 
      x = TApplicationException()
1173 
      x.read(self._iprot)
1174 
      self._iprot.readMessageEnd()
1175 
      raise x
1176 
    result = updateItem_result()
1177 
    result.read(self._iprot)
1178 
    self._iprot.readMessageEnd()
1179 
    if result.success is not None:
1180 
      return result.success
1181 
    if result.cex is not None:
1182 
      raise result.cex
1183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1184 
 
1185 
  def isActive(self, itemId):
1186 
    """
1187 
    Checks if the item given to the corresponding itemId is active. If it's active,
1188 
    whether it's risky and if it's risky, its inventory position.
1189 
 
1190 
    Parameters:
1191 
     - itemId
1192 
    """
1193 
    self.send_isActive(itemId)
1194 
    return self.recv_isActive()
1195 
 
1196 
  def send_isActive(self, itemId):
1197 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1198 
    args = isActive_args()
1199 
    args.itemId = itemId
1200 
    args.write(self._oprot)
1201 
    self._oprot.writeMessageEnd()
1202 
    self._oprot.trans.flush()
1203 
 
1204 
  def recv_isActive(self, ):
1205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1206 
    if mtype == TMessageType.EXCEPTION:
1207 
      x = TApplicationException()
1208 
      x.read(self._iprot)
1209 
      self._iprot.readMessageEnd()
1210 
      raise x
1211 
    result = isActive_result()
1212 
    result.read(self._iprot)
1213 
    self._iprot.readMessageEnd()
1214 
    if result.success is not None:
1215 
      return result.success
1216 
    if result.isex is not None:
1217 
      raise result.isex
1218 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1219 
 
7438 amit.gupta 1220 
  def getItemsStatus(self, itemIds):
1221 
    """
1222 
    Parameters:
1223 
     - itemIds
1224 
    """
1225 
    self.send_getItemsStatus(itemIds)
1226 
    return self.recv_getItemsStatus()
1227 
 
1228 
  def send_getItemsStatus(self, itemIds):
1229 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1230 
    args = getItemsStatus_args()
1231 
    args.itemIds = itemIds
1232 
    args.write(self._oprot)
1233 
    self._oprot.writeMessageEnd()
1234 
    self._oprot.trans.flush()
1235 
 
1236 
  def recv_getItemsStatus(self, ):
1237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1238 
    if mtype == TMessageType.EXCEPTION:
1239 
      x = TApplicationException()
1240 
      x.read(self._iprot)
1241 
      self._iprot.readMessageEnd()
1242 
      raise x
1243 
    result = getItemsStatus_result()
1244 
    result.read(self._iprot)
1245 
    self._iprot.readMessageEnd()
1246 
    if result.success is not None:
1247 
      return result.success
1248 
    if result.isex is not None:
1249 
      raise result.isex
1250 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1251 
 
5944 mandeep.dh 1252 
  def getItemStatusDescription(self, itemId):
1253 
    """
1254 
    Parameters:
1255 
     - itemId
1256 
    """
1257 
    self.send_getItemStatusDescription(itemId)
1258 
    return self.recv_getItemStatusDescription()
1259 
 
1260 
  def send_getItemStatusDescription(self, itemId):
1261 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1262 
    args = getItemStatusDescription_args()
1263 
    args.itemId = itemId
1264 
    args.write(self._oprot)
1265 
    self._oprot.writeMessageEnd()
1266 
    self._oprot.trans.flush()
1267 
 
1268 
  def recv_getItemStatusDescription(self, ):
1269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1270 
    if mtype == TMessageType.EXCEPTION:
1271 
      x = TApplicationException()
1272 
      x.read(self._iprot)
1273 
      self._iprot.readMessageEnd()
1274 
      raise x
1275 
    result = getItemStatusDescription_result()
1276 
    result.read(self._iprot)
1277 
    self._iprot.readMessageEnd()
1278 
    if result.success is not None:
1279 
      return result.success
1280 
    if result.isex is not None:
1281 
      raise result.isex
1282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1283 
 
1284 
  def startItemOn(self, item_id, timestamp):
1285 
    """
1286 
    Parameters:
1287 
     - item_id
1288 
     - timestamp
1289 
    """
1290 
    self.send_startItemOn(item_id, timestamp)
1291 
    self.recv_startItemOn()
1292 
 
1293 
  def send_startItemOn(self, item_id, timestamp):
1294 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1295 
    args = startItemOn_args()
1296 
    args.item_id = item_id
1297 
    args.timestamp = timestamp
1298 
    args.write(self._oprot)
1299 
    self._oprot.writeMessageEnd()
1300 
    self._oprot.trans.flush()
1301 
 
1302 
  def recv_startItemOn(self, ):
1303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1304 
    if mtype == TMessageType.EXCEPTION:
1305 
      x = TApplicationException()
1306 
      x.read(self._iprot)
1307 
      self._iprot.readMessageEnd()
1308 
      raise x
1309 
    result = startItemOn_result()
1310 
    result.read(self._iprot)
1311 
    self._iprot.readMessageEnd()
1312 
    if result.cex is not None:
1313 
      raise result.cex
1314 
    return
1315 
 
1316 
  def retireItemOn(self, item_id, timestamp):
1317 
    """
1318 
    Parameters:
1319 
     - item_id
1320 
     - timestamp
1321 
    """
1322 
    self.send_retireItemOn(item_id, timestamp)
1323 
    self.recv_retireItemOn()
1324 
 
1325 
  def send_retireItemOn(self, item_id, timestamp):
1326 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1327 
    args = retireItemOn_args()
1328 
    args.item_id = item_id
1329 
    args.timestamp = timestamp
1330 
    args.write(self._oprot)
1331 
    self._oprot.writeMessageEnd()
1332 
    self._oprot.trans.flush()
1333 
 
1334 
  def recv_retireItemOn(self, ):
1335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1336 
    if mtype == TMessageType.EXCEPTION:
1337 
      x = TApplicationException()
1338 
      x.read(self._iprot)
1339 
      self._iprot.readMessageEnd()
1340 
      raise x
1341 
    result = retireItemOn_result()
1342 
    result.read(self._iprot)
1343 
    self._iprot.readMessageEnd()
1344 
    if result.cex is not None:
1345 
      raise result.cex
1346 
    return
1347 
 
1348 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1349 
    """
1350 
    Parameters:
1351 
     - item_id
1352 
     - timestamp
1353 
     - newstatus
1354 
    """
1355 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1356 
    self.recv_changeItemStatus()
1357 
 
1358 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1359 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1360 
    args = changeItemStatus_args()
1361 
    args.item_id = item_id
1362 
    args.timestamp = timestamp
1363 
    args.newstatus = newstatus
1364 
    args.write(self._oprot)
1365 
    self._oprot.writeMessageEnd()
1366 
    self._oprot.trans.flush()
1367 
 
1368 
  def recv_changeItemStatus(self, ):
1369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1370 
    if mtype == TMessageType.EXCEPTION:
1371 
      x = TApplicationException()
1372 
      x.read(self._iprot)
1373 
      self._iprot.readMessageEnd()
1374 
      raise x
1375 
    result = changeItemStatus_result()
1376 
    result.read(self._iprot)
1377 
    self._iprot.readMessageEnd()
1378 
    if result.cex is not None:
1379 
      raise result.cex
1380 
    return
1381 
 
1382 
  def getItem(self, item_id):
1383 
    """
1384 
    Parameters:
1385 
     - item_id
1386 
    """
1387 
    self.send_getItem(item_id)
1388 
    return self.recv_getItem()
1389 
 
1390 
  def send_getItem(self, item_id):
1391 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1392 
    args = getItem_args()
1393 
    args.item_id = item_id
1394 
    args.write(self._oprot)
1395 
    self._oprot.writeMessageEnd()
1396 
    self._oprot.trans.flush()
1397 
 
1398 
  def recv_getItem(self, ):
1399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1400 
    if mtype == TMessageType.EXCEPTION:
1401 
      x = TApplicationException()
1402 
      x.read(self._iprot)
1403 
      self._iprot.readMessageEnd()
1404 
      raise x
1405 
    result = getItem_result()
1406 
    result.read(self._iprot)
1407 
    self._iprot.readMessageEnd()
1408 
    if result.success is not None:
1409 
      return result.success
1410 
    if result.cex is not None:
1411 
      raise result.cex
1412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1413 
 
1414 
  def getItemsByCatalogId(self, catalog_item_id):
1415 
    """
1416 
    Parameters:
1417 
     - catalog_item_id
1418 
    """
1419 
    self.send_getItemsByCatalogId(catalog_item_id)
1420 
    return self.recv_getItemsByCatalogId()
1421 
 
1422 
  def send_getItemsByCatalogId(self, catalog_item_id):
1423 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1424 
    args = getItemsByCatalogId_args()
1425 
    args.catalog_item_id = catalog_item_id
1426 
    args.write(self._oprot)
1427 
    self._oprot.writeMessageEnd()
1428 
    self._oprot.trans.flush()
1429 
 
1430 
  def recv_getItemsByCatalogId(self, ):
1431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1432 
    if mtype == TMessageType.EXCEPTION:
1433 
      x = TApplicationException()
1434 
      x.read(self._iprot)
1435 
      self._iprot.readMessageEnd()
1436 
      raise x
1437 
    result = getItemsByCatalogId_result()
1438 
    result.read(self._iprot)
1439 
    self._iprot.readMessageEnd()
1440 
    if result.success is not None:
1441 
      return result.success
1442 
    if result.cex is not None:
1443 
      raise result.cex
1444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1445 
 
1446 
  def getValidItemsByCatalogId(self, catalog_item_id):
1447 
    """
1448 
    Parameters:
1449 
     - catalog_item_id
1450 
    """
1451 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1452 
    return self.recv_getValidItemsByCatalogId()
1453 
 
1454 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1455 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1456 
    args = getValidItemsByCatalogId_args()
1457 
    args.catalog_item_id = catalog_item_id
1458 
    args.write(self._oprot)
1459 
    self._oprot.writeMessageEnd()
1460 
    self._oprot.trans.flush()
1461 
 
1462 
  def recv_getValidItemsByCatalogId(self, ):
1463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1464 
    if mtype == TMessageType.EXCEPTION:
1465 
      x = TApplicationException()
1466 
      x.read(self._iprot)
1467 
      self._iprot.readMessageEnd()
1468 
      raise x
1469 
    result = getValidItemsByCatalogId_result()
1470 
    result.read(self._iprot)
1471 
    self._iprot.readMessageEnd()
1472 
    if result.success is not None:
1473 
      return result.success
1474 
    if result.cex is not None:
1475 
      raise result.cex
1476 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1477 
 
1478 
  def getAllItems(self, isActive):
1479 
    """
1480 
    Parameters:
1481 
     - isActive
1482 
    """
1483 
    self.send_getAllItems(isActive)
1484 
    return self.recv_getAllItems()
1485 
 
1486 
  def send_getAllItems(self, isActive):
1487 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1488 
    args = getAllItems_args()
1489 
    args.isActive = isActive
1490 
    args.write(self._oprot)
1491 
    self._oprot.writeMessageEnd()
1492 
    self._oprot.trans.flush()
1493 
 
1494 
  def recv_getAllItems(self, ):
1495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1496 
    if mtype == TMessageType.EXCEPTION:
1497 
      x = TApplicationException()
1498 
      x.read(self._iprot)
1499 
      self._iprot.readMessageEnd()
1500 
      raise x
1501 
    result = getAllItems_result()
1502 
    result.read(self._iprot)
1503 
    self._iprot.readMessageEnd()
1504 
    if result.success is not None:
1505 
      return result.success
1506 
    if result.cex is not None:
1507 
      raise result.cex
1508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1509 
 
1510 
  def getAllItemsByStatus(self, itemStatus):
1511 
    """
1512 
    Parameters:
1513 
     - itemStatus
1514 
    """
1515 
    self.send_getAllItemsByStatus(itemStatus)
1516 
    return self.recv_getAllItemsByStatus()
1517 
 
1518 
  def send_getAllItemsByStatus(self, itemStatus):
1519 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1520 
    args = getAllItemsByStatus_args()
1521 
    args.itemStatus = itemStatus
1522 
    args.write(self._oprot)
1523 
    self._oprot.writeMessageEnd()
1524 
    self._oprot.trans.flush()
1525 
 
1526 
  def recv_getAllItemsByStatus(self, ):
1527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1528 
    if mtype == TMessageType.EXCEPTION:
1529 
      x = TApplicationException()
1530 
      x.read(self._iprot)
1531 
      self._iprot.readMessageEnd()
1532 
      raise x
1533 
    result = getAllItemsByStatus_result()
1534 
    result.read(self._iprot)
1535 
    self._iprot.readMessageEnd()
1536 
    if result.success is not None:
1537 
      return result.success
1538 
    if result.cex is not None:
1539 
      raise result.cex
1540 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1541 
 
9253 rajveer 1542 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1543 
    """
1544 
    Parameters:
1545 
     - entityId
1546 
     - category
1547 
     - brand
1548 
     - modelName
1549 
     - modelNumber
9253 rajveer 1550 
     - isAndroid
5944 mandeep.dh 1551 
    """
9253 rajveer 1552 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1553 
    return self.recv_markItemAsContentComplete()
1554 
 
9253 rajveer 1555 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1556 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1557 
    args = markItemAsContentComplete_args()
1558 
    args.entityId = entityId
1559 
    args.category = category
1560 
    args.brand = brand
1561 
    args.modelName = modelName
1562 
    args.modelNumber = modelNumber
9253 rajveer 1563 
    args.isAndroid = isAndroid
5944 mandeep.dh 1564 
    args.write(self._oprot)
1565 
    self._oprot.writeMessageEnd()
1566 
    self._oprot.trans.flush()
1567 
 
1568 
  def recv_markItemAsContentComplete(self, ):
1569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1570 
    if mtype == TMessageType.EXCEPTION:
1571 
      x = TApplicationException()
1572 
      x.read(self._iprot)
1573 
      self._iprot.readMessageEnd()
1574 
      raise x
1575 
    result = markItemAsContentComplete_result()
1576 
    result.read(self._iprot)
1577 
    self._iprot.readMessageEnd()
1578 
    if result.success is not None:
1579 
      return result.success
1580 
    if result.cex is not None:
1581 
      raise result.cex
1582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1583 
 
1584 
  def getAllItemsInRange(self, offset, limit):
1585 
    """
1586 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1587 
 
1588 
    Parameters:
1589 
     - offset
1590 
     - limit
1591 
    """
1592 
    self.send_getAllItemsInRange(offset, limit)
1593 
    return self.recv_getAllItemsInRange()
1594 
 
1595 
  def send_getAllItemsInRange(self, offset, limit):
1596 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1597 
    args = getAllItemsInRange_args()
1598 
    args.offset = offset
1599 
    args.limit = limit
1600 
    args.write(self._oprot)
1601 
    self._oprot.writeMessageEnd()
1602 
    self._oprot.trans.flush()
1603 
 
1604 
  def recv_getAllItemsInRange(self, ):
1605 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1606 
    if mtype == TMessageType.EXCEPTION:
1607 
      x = TApplicationException()
1608 
      x.read(self._iprot)
1609 
      self._iprot.readMessageEnd()
1610 
      raise x
1611 
    result = getAllItemsInRange_result()
1612 
    result.read(self._iprot)
1613 
    self._iprot.readMessageEnd()
1614 
    if result.success is not None:
1615 
      return result.success
1616 
    if result.cex is not None:
1617 
      raise result.cex
1618 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1619 
 
1620 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1621 
    """
1622 
    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.
1623 
 
1624 
    Parameters:
1625 
     - itemStatus
1626 
     - offset
1627 
     - limit
1628 
    """
1629 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1630 
    return self.recv_getAllItemsByStatusInRange()
1631 
 
1632 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1633 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1634 
    args = getAllItemsByStatusInRange_args()
1635 
    args.itemStatus = itemStatus
1636 
    args.offset = offset
1637 
    args.limit = limit
1638 
    args.write(self._oprot)
1639 
    self._oprot.writeMessageEnd()
1640 
    self._oprot.trans.flush()
1641 
 
1642 
  def recv_getAllItemsByStatusInRange(self, ):
1643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1644 
    if mtype == TMessageType.EXCEPTION:
1645 
      x = TApplicationException()
1646 
      x.read(self._iprot)
1647 
      self._iprot.readMessageEnd()
1648 
      raise x
1649 
    result = getAllItemsByStatusInRange_result()
1650 
    result.read(self._iprot)
1651 
    self._iprot.readMessageEnd()
1652 
    if result.success is not None:
1653 
      return result.success
1654 
    if result.cex is not None:
1655 
      raise result.cex
1656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1657 
 
1658 
  def getItemCountByStatus(self, useStatus, itemStatus):
1659 
    """
1660 
    Gets a count of all items by status
1661 
 
1662 
    Parameters:
1663 
     - useStatus
1664 
     - itemStatus
1665 
    """
1666 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1667 
    return self.recv_getItemCountByStatus()
1668 
 
1669 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1670 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1671 
    args = getItemCountByStatus_args()
1672 
    args.useStatus = useStatus
1673 
    args.itemStatus = itemStatus
1674 
    args.write(self._oprot)
1675 
    self._oprot.writeMessageEnd()
1676 
    self._oprot.trans.flush()
1677 
 
1678 
  def recv_getItemCountByStatus(self, ):
1679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1680 
    if mtype == TMessageType.EXCEPTION:
1681 
      x = TApplicationException()
1682 
      x.read(self._iprot)
1683 
      self._iprot.readMessageEnd()
1684 
      raise x
1685 
    result = getItemCountByStatus_result()
1686 
    result.read(self._iprot)
1687 
    self._iprot.readMessageEnd()
1688 
    if result.success is not None:
1689 
      return result.success
1690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1691 
 
1692 
  def getBestSellers(self, ):
1693 
    self.send_getBestSellers()
1694 
    return self.recv_getBestSellers()
1695 
 
1696 
  def send_getBestSellers(self, ):
1697 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1698 
    args = getBestSellers_args()
1699 
    args.write(self._oprot)
1700 
    self._oprot.writeMessageEnd()
1701 
    self._oprot.trans.flush()
1702 
 
1703 
  def recv_getBestSellers(self, ):
1704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1705 
    if mtype == TMessageType.EXCEPTION:
1706 
      x = TApplicationException()
1707 
      x.read(self._iprot)
1708 
      self._iprot.readMessageEnd()
1709 
      raise x
1710 
    result = getBestSellers_result()
1711 
    result.read(self._iprot)
1712 
    self._iprot.readMessageEnd()
1713 
    if result.success is not None:
1714 
      return result.success
1715 
    if result.isex is not None:
1716 
      raise result.isex
1717 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1718 
 
1719 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1720 
    """
1721 
    Parameters:
1722 
     - beginIndex
1723 
     - totalItems
1724 
     - brand
1725 
     - category
1726 
    """
1727 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1728 
    return self.recv_getBestSellersCatalogIds()
1729 
 
1730 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1731 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1732 
    args = getBestSellersCatalogIds_args()
1733 
    args.beginIndex = beginIndex
1734 
    args.totalItems = totalItems
1735 
    args.brand = brand
1736 
    args.category = category
1737 
    args.write(self._oprot)
1738 
    self._oprot.writeMessageEnd()
1739 
    self._oprot.trans.flush()
1740 
 
1741 
  def recv_getBestSellersCatalogIds(self, ):
1742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1743 
    if mtype == TMessageType.EXCEPTION:
1744 
      x = TApplicationException()
1745 
      x.read(self._iprot)
1746 
      self._iprot.readMessageEnd()
1747 
      raise x
1748 
    result = getBestSellersCatalogIds_result()
1749 
    result.read(self._iprot)
1750 
    self._iprot.readMessageEnd()
1751 
    if result.success is not None:
1752 
      return result.success
1753 
    if result.cex is not None:
1754 
      raise result.cex
1755 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1756 
 
1757 
  def getBestSellersCount(self, ):
1758 
    self.send_getBestSellersCount()
1759 
    return self.recv_getBestSellersCount()
1760 
 
1761 
  def send_getBestSellersCount(self, ):
1762 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1763 
    args = getBestSellersCount_args()
1764 
    args.write(self._oprot)
1765 
    self._oprot.writeMessageEnd()
1766 
    self._oprot.trans.flush()
1767 
 
1768 
  def recv_getBestSellersCount(self, ):
1769 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1770 
    if mtype == TMessageType.EXCEPTION:
1771 
      x = TApplicationException()
1772 
      x.read(self._iprot)
1773 
      self._iprot.readMessageEnd()
1774 
      raise x
1775 
    result = getBestSellersCount_result()
1776 
    result.read(self._iprot)
1777 
    self._iprot.readMessageEnd()
1778 
    if result.success is not None:
1779 
      return result.success
1780 
    if result.cex is not None:
1781 
      raise result.cex
1782 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1783 
 
1784 
  def getBestDeals(self, ):
1785 
    self.send_getBestDeals()
1786 
    return self.recv_getBestDeals()
1787 
 
1788 
  def send_getBestDeals(self, ):
1789 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1790 
    args = getBestDeals_args()
1791 
    args.write(self._oprot)
1792 
    self._oprot.writeMessageEnd()
1793 
    self._oprot.trans.flush()
1794 
 
1795 
  def recv_getBestDeals(self, ):
1796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1797 
    if mtype == TMessageType.EXCEPTION:
1798 
      x = TApplicationException()
1799 
      x.read(self._iprot)
1800 
      self._iprot.readMessageEnd()
1801 
      raise x
1802 
    result = getBestDeals_result()
1803 
    result.read(self._iprot)
1804 
    self._iprot.readMessageEnd()
1805 
    if result.success is not None:
1806 
      return result.success
1807 
    if result.isex is not None:
1808 
      raise result.isex
1809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1810 
 
1811 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1812 
    """
1813 
    Parameters:
1814 
     - beginIndex
1815 
     - totalItems
1816 
     - brand
1817 
     - category
1818 
    """
1819 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1820 
    return self.recv_getBestDealsCatalogIds()
1821 
 
1822 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1823 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1824 
    args = getBestDealsCatalogIds_args()
1825 
    args.beginIndex = beginIndex
1826 
    args.totalItems = totalItems
1827 
    args.brand = brand
1828 
    args.category = category
1829 
    args.write(self._oprot)
1830 
    self._oprot.writeMessageEnd()
1831 
    self._oprot.trans.flush()
1832 
 
1833 
  def recv_getBestDealsCatalogIds(self, ):
1834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1835 
    if mtype == TMessageType.EXCEPTION:
1836 
      x = TApplicationException()
1837 
      x.read(self._iprot)
1838 
      self._iprot.readMessageEnd()
1839 
      raise x
1840 
    result = getBestDealsCatalogIds_result()
1841 
    result.read(self._iprot)
1842 
    self._iprot.readMessageEnd()
1843 
    if result.success is not None:
1844 
      return result.success
1845 
    if result.cex is not None:
1846 
      raise result.cex
1847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1848 
 
1849 
  def getBestDealsCount(self, ):
1850 
    self.send_getBestDealsCount()
1851 
    return self.recv_getBestDealsCount()
1852 
 
1853 
  def send_getBestDealsCount(self, ):
1854 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1855 
    args = getBestDealsCount_args()
1856 
    args.write(self._oprot)
1857 
    self._oprot.writeMessageEnd()
1858 
    self._oprot.trans.flush()
1859 
 
1860 
  def recv_getBestDealsCount(self, ):
1861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1862 
    if mtype == TMessageType.EXCEPTION:
1863 
      x = TApplicationException()
1864 
      x.read(self._iprot)
1865 
      self._iprot.readMessageEnd()
1866 
      raise x
1867 
    result = getBestDealsCount_result()
1868 
    result.read(self._iprot)
1869 
    self._iprot.readMessageEnd()
1870 
    if result.success is not None:
1871 
      return result.success
1872 
    if result.cex is not None:
1873 
      raise result.cex
1874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1875 
 
1876 
  def getComingSoon(self, ):
1877 
    self.send_getComingSoon()
1878 
    return self.recv_getComingSoon()
1879 
 
1880 
  def send_getComingSoon(self, ):
1881 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1882 
    args = getComingSoon_args()
1883 
    args.write(self._oprot)
1884 
    self._oprot.writeMessageEnd()
1885 
    self._oprot.trans.flush()
1886 
 
1887 
  def recv_getComingSoon(self, ):
1888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1889 
    if mtype == TMessageType.EXCEPTION:
1890 
      x = TApplicationException()
1891 
      x.read(self._iprot)
1892 
      self._iprot.readMessageEnd()
1893 
      raise x
1894 
    result = getComingSoon_result()
1895 
    result.read(self._iprot)
1896 
    self._iprot.readMessageEnd()
1897 
    if result.success is not None:
1898 
      return result.success
1899 
    if result.isex is not None:
1900 
      raise result.isex
1901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1902 
 
1903 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1904 
    """
1905 
    Parameters:
1906 
     - beginIndex
1907 
     - totalItems
1908 
     - brand
1909 
     - category
1910 
    """
1911 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1912 
    return self.recv_getComingSoonCatalogIds()
1913 
 
1914 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1915 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1916 
    args = getComingSoonCatalogIds_args()
1917 
    args.beginIndex = beginIndex
1918 
    args.totalItems = totalItems
1919 
    args.brand = brand
1920 
    args.category = category
1921 
    args.write(self._oprot)
1922 
    self._oprot.writeMessageEnd()
1923 
    self._oprot.trans.flush()
1924 
 
1925 
  def recv_getComingSoonCatalogIds(self, ):
1926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1927 
    if mtype == TMessageType.EXCEPTION:
1928 
      x = TApplicationException()
1929 
      x.read(self._iprot)
1930 
      self._iprot.readMessageEnd()
1931 
      raise x
1932 
    result = getComingSoonCatalogIds_result()
1933 
    result.read(self._iprot)
1934 
    self._iprot.readMessageEnd()
1935 
    if result.success is not None:
1936 
      return result.success
1937 
    if result.cex is not None:
1938 
      raise result.cex
1939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1940 
 
1941 
  def getComingSoonCount(self, ):
1942 
    self.send_getComingSoonCount()
1943 
    return self.recv_getComingSoonCount()
1944 
 
1945 
  def send_getComingSoonCount(self, ):
1946 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1947 
    args = getComingSoonCount_args()
1948 
    args.write(self._oprot)
1949 
    self._oprot.writeMessageEnd()
1950 
    self._oprot.trans.flush()
1951 
 
1952 
  def recv_getComingSoonCount(self, ):
1953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1954 
    if mtype == TMessageType.EXCEPTION:
1955 
      x = TApplicationException()
1956 
      x.read(self._iprot)
1957 
      self._iprot.readMessageEnd()
1958 
      raise x
1959 
    result = getComingSoonCount_result()
1960 
    result.read(self._iprot)
1961 
    self._iprot.readMessageEnd()
1962 
    if result.success is not None:
1963 
      return result.success
1964 
    if result.cex is not None:
1965 
      raise result.cex
1966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1967 
 
1968 
  def getLatestArrivals(self, ):
1969 
    """
1970 
    Returns a list of items sorted in the descending order by start date.
1971 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1972 
    """
1973 
    self.send_getLatestArrivals()
1974 
    return self.recv_getLatestArrivals()
1975 
 
1976 
  def send_getLatestArrivals(self, ):
1977 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1978 
    args = getLatestArrivals_args()
1979 
    args.write(self._oprot)
1980 
    self._oprot.writeMessageEnd()
1981 
    self._oprot.trans.flush()
1982 
 
1983 
  def recv_getLatestArrivals(self, ):
1984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1985 
    if mtype == TMessageType.EXCEPTION:
1986 
      x = TApplicationException()
1987 
      x.read(self._iprot)
1988 
      self._iprot.readMessageEnd()
1989 
      raise x
1990 
    result = getLatestArrivals_result()
1991 
    result.read(self._iprot)
1992 
    self._iprot.readMessageEnd()
1993 
    if result.success is not None:
1994 
      return result.success
1995 
    if result.isex is not None:
1996 
      raise result.isex
1997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1998 
 
1999 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2000 
    """
2001 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
2002 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
2003 
 
2004 
    Parameters:
2005 
     - beginIndex
2006 
     - totalItems
2007 
     - brand
2008 
     - categories
2009 
    """
2010 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
2011 
    return self.recv_getLatestArrivalsCatalogIds()
2012 
 
2013 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2014 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
2015 
    args = getLatestArrivalsCatalogIds_args()
2016 
    args.beginIndex = beginIndex
2017 
    args.totalItems = totalItems
2018 
    args.brand = brand
2019 
    args.categories = categories
2020 
    args.write(self._oprot)
2021 
    self._oprot.writeMessageEnd()
2022 
    self._oprot.trans.flush()
2023 
 
2024 
  def recv_getLatestArrivalsCatalogIds(self, ):
2025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2026 
    if mtype == TMessageType.EXCEPTION:
2027 
      x = TApplicationException()
2028 
      x.read(self._iprot)
2029 
      self._iprot.readMessageEnd()
2030 
      raise x
2031 
    result = getLatestArrivalsCatalogIds_result()
2032 
    result.read(self._iprot)
2033 
    self._iprot.readMessageEnd()
2034 
    if result.success is not None:
2035 
      return result.success
2036 
    if result.cex is not None:
2037 
      raise result.cex
2038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
2039 
 
2040 
  def getLatestArrivalsCount(self, ):
2041 
    """
2042 
    Get the total number of latest arrivals we are willing to show.
2043 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
2044 
    """
2045 
    self.send_getLatestArrivalsCount()
2046 
    return self.recv_getLatestArrivalsCount()
2047 
 
2048 
  def send_getLatestArrivalsCount(self, ):
2049 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
2050 
    args = getLatestArrivalsCount_args()
2051 
    args.write(self._oprot)
2052 
    self._oprot.writeMessageEnd()
2053 
    self._oprot.trans.flush()
2054 
 
2055 
  def recv_getLatestArrivalsCount(self, ):
2056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2057 
    if mtype == TMessageType.EXCEPTION:
2058 
      x = TApplicationException()
2059 
      x.read(self._iprot)
2060 
      self._iprot.readMessageEnd()
2061 
      raise x
2062 
    result = getLatestArrivalsCount_result()
2063 
    result.read(self._iprot)
2064 
    self._iprot.readMessageEnd()
2065 
    if result.success is not None:
2066 
      return result.success
2067 
    if result.cex is not None:
2068 
      raise result.cex
2069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
2070 
 
2071 
  def generateNewEntityID(self, ):
2072 
    self.send_generateNewEntityID()
2073 
    return self.recv_generateNewEntityID()
2074 
 
2075 
  def send_generateNewEntityID(self, ):
2076 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2077 
    args = generateNewEntityID_args()
2078 
    args.write(self._oprot)
2079 
    self._oprot.writeMessageEnd()
2080 
    self._oprot.trans.flush()
2081 
 
2082 
  def recv_generateNewEntityID(self, ):
2083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2084 
    if mtype == TMessageType.EXCEPTION:
2085 
      x = TApplicationException()
2086 
      x.read(self._iprot)
2087 
      self._iprot.readMessageEnd()
2088 
      raise x
2089 
    result = generateNewEntityID_result()
2090 
    result.read(self._iprot)
2091 
    self._iprot.readMessageEnd()
2092 
    if result.success is not None:
2093 
      return result.success
2094 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2095 
 
2096 
  def addCategory(self, category):
2097 
    """
2098 
    All category related functions
2099 
 
2100 
    Parameters:
2101 
     - category
2102 
    """
2103 
    self.send_addCategory(category)
2104 
    return self.recv_addCategory()
2105 
 
2106 
  def send_addCategory(self, category):
2107 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2108 
    args = addCategory_args()
2109 
    args.category = category
2110 
    args.write(self._oprot)
2111 
    self._oprot.writeMessageEnd()
2112 
    self._oprot.trans.flush()
2113 
 
2114 
  def recv_addCategory(self, ):
2115 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2116 
    if mtype == TMessageType.EXCEPTION:
2117 
      x = TApplicationException()
2118 
      x.read(self._iprot)
2119 
      self._iprot.readMessageEnd()
2120 
      raise x
2121 
    result = addCategory_result()
2122 
    result.read(self._iprot)
2123 
    self._iprot.readMessageEnd()
2124 
    if result.success is not None:
2125 
      return result.success
2126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2127 
 
2128 
  def getCategory(self, id):
2129 
    """
2130 
    Parameters:
2131 
     - id
2132 
    """
2133 
    self.send_getCategory(id)
2134 
    return self.recv_getCategory()
2135 
 
2136 
  def send_getCategory(self, id):
2137 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2138 
    args = getCategory_args()
2139 
    args.id = id
2140 
    args.write(self._oprot)
2141 
    self._oprot.writeMessageEnd()
2142 
    self._oprot.trans.flush()
2143 
 
2144 
  def recv_getCategory(self, ):
2145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2146 
    if mtype == TMessageType.EXCEPTION:
2147 
      x = TApplicationException()
2148 
      x.read(self._iprot)
2149 
      self._iprot.readMessageEnd()
2150 
      raise x
2151 
    result = getCategory_result()
2152 
    result.read(self._iprot)
2153 
    self._iprot.readMessageEnd()
2154 
    if result.success is not None:
2155 
      return result.success
2156 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2157 
 
2158 
  def getAllCategories(self, ):
2159 
    self.send_getAllCategories()
2160 
    return self.recv_getAllCategories()
2161 
 
2162 
  def send_getAllCategories(self, ):
2163 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2164 
    args = getAllCategories_args()
2165 
    args.write(self._oprot)
2166 
    self._oprot.writeMessageEnd()
2167 
    self._oprot.trans.flush()
2168 
 
2169 
  def recv_getAllCategories(self, ):
2170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2171 
    if mtype == TMessageType.EXCEPTION:
2172 
      x = TApplicationException()
2173 
      x.read(self._iprot)
2174 
      self._iprot.readMessageEnd()
2175 
      raise x
2176 
    result = getAllCategories_result()
2177 
    result.read(self._iprot)
2178 
    self._iprot.readMessageEnd()
2179 
    if result.success is not None:
2180 
      return result.success
2181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2182 
 
2183 
  def getAllSimilarItems(self, itemId):
2184 
    """
2185 
    Returns the list of similar items.
2186 
 
2187 
    Parameters:
2188 
     - itemId
2189 
    """
2190 
    self.send_getAllSimilarItems(itemId)
2191 
    return self.recv_getAllSimilarItems()
2192 
 
2193 
  def send_getAllSimilarItems(self, itemId):
2194 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2195 
    args = getAllSimilarItems_args()
2196 
    args.itemId = itemId
2197 
    args.write(self._oprot)
2198 
    self._oprot.writeMessageEnd()
2199 
    self._oprot.trans.flush()
2200 
 
2201 
  def recv_getAllSimilarItems(self, ):
2202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2203 
    if mtype == TMessageType.EXCEPTION:
2204 
      x = TApplicationException()
2205 
      x.read(self._iprot)
2206 
      self._iprot.readMessageEnd()
2207 
      raise x
2208 
    result = getAllSimilarItems_result()
2209 
    result.read(self._iprot)
2210 
    self._iprot.readMessageEnd()
2211 
    if result.success is not None:
2212 
      return result.success
2213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2214 
 
2215 
  def addSimilarItem(self, itemId, catalogItemId):
2216 
    """
2217 
    Adds similar item.
2218 
 
2219 
    Parameters:
2220 
     - itemId
2221 
     - catalogItemId
2222 
    """
2223 
    self.send_addSimilarItem(itemId, catalogItemId)
2224 
    return self.recv_addSimilarItem()
2225 
 
2226 
  def send_addSimilarItem(self, itemId, catalogItemId):
2227 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2228 
    args = addSimilarItem_args()
2229 
    args.itemId = itemId
2230 
    args.catalogItemId = catalogItemId
2231 
    args.write(self._oprot)
2232 
    self._oprot.writeMessageEnd()
2233 
    self._oprot.trans.flush()
2234 
 
2235 
  def recv_addSimilarItem(self, ):
2236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2237 
    if mtype == TMessageType.EXCEPTION:
2238 
      x = TApplicationException()
2239 
      x.read(self._iprot)
2240 
      self._iprot.readMessageEnd()
2241 
      raise x
2242 
    result = addSimilarItem_result()
2243 
    result.read(self._iprot)
2244 
    self._iprot.readMessageEnd()
2245 
    if result.success is not None:
2246 
      return result.success
2247 
    if result.cex is not None:
2248 
      raise result.cex
2249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2250 
 
6512 kshitij.so 2251 
  def addTag(self, displayName, itemId):
2252 
    """
2253 
    Tag Related
2254 
 
2255 
    Parameters:
2256 
     - displayName
2257 
     - itemId
2258 
    """
2259 
    self.send_addTag(displayName, itemId)
2260 
    return self.recv_addTag()
2261 
 
2262 
  def send_addTag(self, displayName, itemId):
2263 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2264 
    args = addTag_args()
2265 
    args.displayName = displayName
2266 
    args.itemId = itemId
2267 
    args.write(self._oprot)
2268 
    self._oprot.writeMessageEnd()
2269 
    self._oprot.trans.flush()
2270 
 
2271 
  def recv_addTag(self, ):
2272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2273 
    if mtype == TMessageType.EXCEPTION:
2274 
      x = TApplicationException()
2275 
      x.read(self._iprot)
2276 
      self._iprot.readMessageEnd()
2277 
      raise x
2278 
    result = addTag_result()
2279 
    result.read(self._iprot)
2280 
    self._iprot.readMessageEnd()
2281 
    if result.success is not None:
2282 
      return result.success
2283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2284 
 
2285 
  def deleteEntityTag(self, displayName, itemId):
2286 
    """
2287 
    Parameters:
2288 
     - displayName
2289 
     - itemId
2290 
    """
2291 
    self.send_deleteEntityTag(displayName, itemId)
2292 
    return self.recv_deleteEntityTag()
2293 
 
2294 
  def send_deleteEntityTag(self, displayName, itemId):
2295 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2296 
    args = deleteEntityTag_args()
2297 
    args.displayName = displayName
2298 
    args.itemId = itemId
2299 
    args.write(self._oprot)
2300 
    self._oprot.writeMessageEnd()
2301 
    self._oprot.trans.flush()
2302 
 
2303 
  def recv_deleteEntityTag(self, ):
2304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2305 
    if mtype == TMessageType.EXCEPTION:
2306 
      x = TApplicationException()
2307 
      x.read(self._iprot)
2308 
      self._iprot.readMessageEnd()
2309 
      raise x
2310 
    result = deleteEntityTag_result()
2311 
    result.read(self._iprot)
2312 
    self._iprot.readMessageEnd()
2313 
    if result.success is not None:
2314 
      return result.success
2315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2316 
 
2317 
  def deleteTag(self, displayName):
2318 
    """
2319 
    Parameters:
2320 
     - displayName
2321 
    """
2322 
    self.send_deleteTag(displayName)
2323 
    return self.recv_deleteTag()
2324 
 
2325 
  def send_deleteTag(self, displayName):
2326 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2327 
    args = deleteTag_args()
2328 
    args.displayName = displayName
2329 
    args.write(self._oprot)
2330 
    self._oprot.writeMessageEnd()
2331 
    self._oprot.trans.flush()
2332 
 
2333 
  def recv_deleteTag(self, ):
2334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2335 
    if mtype == TMessageType.EXCEPTION:
2336 
      x = TApplicationException()
2337 
      x.read(self._iprot)
2338 
      self._iprot.readMessageEnd()
2339 
      raise x
2340 
    result = deleteTag_result()
2341 
    result.read(self._iprot)
2342 
    self._iprot.readMessageEnd()
2343 
    if result.success is not None:
2344 
      return result.success
2345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2346 
 
2347 
  def getAllTags(self, ):
2348 
    self.send_getAllTags()
2349 
    return self.recv_getAllTags()
2350 
 
2351 
  def send_getAllTags(self, ):
2352 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2353 
    args = getAllTags_args()
2354 
    args.write(self._oprot)
2355 
    self._oprot.writeMessageEnd()
2356 
    self._oprot.trans.flush()
2357 
 
2358 
  def recv_getAllTags(self, ):
2359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2360 
    if mtype == TMessageType.EXCEPTION:
2361 
      x = TApplicationException()
2362 
      x.read(self._iprot)
2363 
      self._iprot.readMessageEnd()
2364 
      raise x
2365 
    result = getAllTags_result()
2366 
    result.read(self._iprot)
2367 
    self._iprot.readMessageEnd()
2368 
    if result.success is not None:
2369 
      return result.success
2370 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2371 
 
2372 
  def getAllEntitiesByTagName(self, displayName):
2373 
    """
2374 
    Parameters:
2375 
     - displayName
2376 
    """
2377 
    self.send_getAllEntitiesByTagName(displayName)
2378 
    return self.recv_getAllEntitiesByTagName()
2379 
 
2380 
  def send_getAllEntitiesByTagName(self, displayName):
2381 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2382 
    args = getAllEntitiesByTagName_args()
2383 
    args.displayName = displayName
2384 
    args.write(self._oprot)
2385 
    self._oprot.writeMessageEnd()
2386 
    self._oprot.trans.flush()
2387 
 
2388 
  def recv_getAllEntitiesByTagName(self, ):
2389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2390 
    if mtype == TMessageType.EXCEPTION:
2391 
      x = TApplicationException()
2392 
      x.read(self._iprot)
2393 
      self._iprot.readMessageEnd()
2394 
      raise x
2395 
    result = getAllEntitiesByTagName_result()
2396 
    result.read(self._iprot)
2397 
    self._iprot.readMessageEnd()
2398 
    if result.success is not None:
2399 
      return result.success
2400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2401 
 
6845 amit.gupta 2402 
  def getAllEntityTags(self, ):
2403 
    self.send_getAllEntityTags()
2404 
    return self.recv_getAllEntityTags()
2405 
 
2406 
  def send_getAllEntityTags(self, ):
2407 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2408 
    args = getAllEntityTags_args()
2409 
    args.write(self._oprot)
2410 
    self._oprot.writeMessageEnd()
2411 
    self._oprot.trans.flush()
2412 
 
2413 
  def recv_getAllEntityTags(self, ):
2414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2415 
    if mtype == TMessageType.EXCEPTION:
2416 
      x = TApplicationException()
2417 
      x.read(self._iprot)
2418 
      self._iprot.readMessageEnd()
2419 
      raise x
2420 
    result = getAllEntityTags_result()
2421 
    result.read(self._iprot)
2422 
    self._iprot.readMessageEnd()
2423 
    if result.success is not None:
2424 
      return result.success
2425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2426 
 
8590 kshitij.so 2427 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2428 
    """
8579 kshitij.so 2429 
    Banner Related
2430 
 
6850 kshitij.so 2431 
    Parameters:
8590 kshitij.so 2432 
     - bannerCongregate
6850 kshitij.so 2433 
    """
8590 kshitij.so 2434 
    self.send_addBanner(bannerCongregate)
10097 kshitij.so 2435 
    return self.recv_addBanner()
6850 kshitij.so 2436 
 
8590 kshitij.so 2437 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2438 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2439 
    args = addBanner_args()
8590 kshitij.so 2440 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2441 
    args.write(self._oprot)
2442 
    self._oprot.writeMessageEnd()
2443 
    self._oprot.trans.flush()
2444 
 
2445 
  def recv_addBanner(self, ):
2446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2447 
    if mtype == TMessageType.EXCEPTION:
2448 
      x = TApplicationException()
2449 
      x.read(self._iprot)
2450 
      self._iprot.readMessageEnd()
2451 
      raise x
2452 
    result = addBanner_result()
2453 
    result.read(self._iprot)
2454 
    self._iprot.readMessageEnd()
10097 kshitij.so 2455 
    if result.success is not None:
2456 
      return result.success
2457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
6850 kshitij.so 2458 
 
8579 kshitij.so 2459 
  def updateBanner(self, banner):
2460 
    """
2461 
    Parameters:
2462 
     - banner
2463 
    """
2464 
    self.send_updateBanner(banner)
2465 
    return self.recv_updateBanner()
2466 
 
2467 
  def send_updateBanner(self, banner):
2468 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2469 
    args = updateBanner_args()
2470 
    args.banner = banner
2471 
    args.write(self._oprot)
2472 
    self._oprot.writeMessageEnd()
2473 
    self._oprot.trans.flush()
2474 
 
2475 
  def recv_updateBanner(self, ):
2476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2477 
    if mtype == TMessageType.EXCEPTION:
2478 
      x = TApplicationException()
2479 
      x.read(self._iprot)
2480 
      self._iprot.readMessageEnd()
2481 
      raise x
2482 
    result = updateBanner_result()
2483 
    result.read(self._iprot)
2484 
    self._iprot.readMessageEnd()
2485 
    if result.success is not None:
2486 
      return result.success
2487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2488 
 
6850 kshitij.so 2489 
  def getAllBanners(self, ):
2490 
    self.send_getAllBanners()
2491 
    return self.recv_getAllBanners()
2492 
 
2493 
  def send_getAllBanners(self, ):
2494 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2495 
    args = getAllBanners_args()
2496 
    args.write(self._oprot)
2497 
    self._oprot.writeMessageEnd()
2498 
    self._oprot.trans.flush()
2499 
 
2500 
  def recv_getAllBanners(self, ):
2501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2502 
    if mtype == TMessageType.EXCEPTION:
2503 
      x = TApplicationException()
2504 
      x.read(self._iprot)
2505 
      self._iprot.readMessageEnd()
2506 
      raise x
2507 
    result = getAllBanners_result()
2508 
    result.read(self._iprot)
2509 
    self._iprot.readMessageEnd()
2510 
    if result.success is not None:
2511 
      return result.success
2512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2513 
 
9155 kshitij.so 2514 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2515 
    """
2516 
    Parameters:
2517 
     - bannerName
9155 kshitij.so 2518 
     - bannerType
6850 kshitij.so 2519 
    """
9155 kshitij.so 2520 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2521 
    return self.recv_deleteBanner()
2522 
 
9155 kshitij.so 2523 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2524 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2525 
    args = deleteBanner_args()
2526 
    args.bannerName = bannerName
9155 kshitij.so 2527 
    args.bannerType = bannerType
6850 kshitij.so 2528 
    args.write(self._oprot)
2529 
    self._oprot.writeMessageEnd()
2530 
    self._oprot.trans.flush()
2531 
 
2532 
  def recv_deleteBanner(self, ):
2533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2534 
    if mtype == TMessageType.EXCEPTION:
2535 
      x = TApplicationException()
2536 
      x.read(self._iprot)
2537 
      self._iprot.readMessageEnd()
2538 
      raise x
2539 
    result = deleteBanner_result()
2540 
    result.read(self._iprot)
2541 
    self._iprot.readMessageEnd()
2542 
    if result.success is not None:
2543 
      return result.success
2544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2545 
 
9155 kshitij.so 2546 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2547 
    """
2548 
    Parameters:
2549 
     - bannerName
9155 kshitij.so 2550 
     - bannerType
6850 kshitij.so 2551 
    """
9155 kshitij.so 2552 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2553 
    return self.recv_getBannerDetails()
2554 
 
9155 kshitij.so 2555 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2556 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2557 
    args = getBannerDetails_args()
2558 
    args.bannerName = bannerName
9155 kshitij.so 2559 
    args.bannerType = bannerType
6850 kshitij.so 2560 
    args.write(self._oprot)
2561 
    self._oprot.writeMessageEnd()
2562 
    self._oprot.trans.flush()
2563 
 
2564 
  def recv_getBannerDetails(self, ):
2565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2566 
    if mtype == TMessageType.EXCEPTION:
2567 
      x = TApplicationException()
2568 
      x.read(self._iprot)
2569 
      self._iprot.readMessageEnd()
2570 
      raise x
2571 
    result = getBannerDetails_result()
2572 
    result.read(self._iprot)
2573 
    self._iprot.readMessageEnd()
2574 
    if result.success is not None:
2575 
      return result.success
2576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2577 
 
2578 
  def getActiveBanners(self, ):
2579 
    self.send_getActiveBanners()
2580 
    return self.recv_getActiveBanners()
2581 
 
2582 
  def send_getActiveBanners(self, ):
2583 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2584 
    args = getActiveBanners_args()
2585 
    args.write(self._oprot)
2586 
    self._oprot.writeMessageEnd()
2587 
    self._oprot.trans.flush()
2588 
 
2589 
  def recv_getActiveBanners(self, ):
2590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2591 
    if mtype == TMessageType.EXCEPTION:
2592 
      x = TApplicationException()
2593 
      x.read(self._iprot)
2594 
      self._iprot.readMessageEnd()
2595 
      raise x
2596 
    result = getActiveBanners_result()
2597 
    result.read(self._iprot)
2598 
    self._iprot.readMessageEnd()
2599 
    if result.success is not None:
2600 
      return result.success
2601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2602 
 
8579 kshitij.so 2603 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2604 
    """
2605 
    Parameters:
8579 kshitij.so 2606 
     - bannerMaps
6849 kshitij.so 2607 
    """
8579 kshitij.so 2608 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2609 
    return self.recv_addBannerMap()
2610 
 
8579 kshitij.so 2611 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2612 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2613 
    args = addBannerMap_args()
8579 kshitij.so 2614 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2615 
    args.write(self._oprot)
2616 
    self._oprot.writeMessageEnd()
2617 
    self._oprot.trans.flush()
2618 
 
2619 
  def recv_addBannerMap(self, ):
2620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2621 
    if mtype == TMessageType.EXCEPTION:
2622 
      x = TApplicationException()
2623 
      x.read(self._iprot)
2624 
      self._iprot.readMessageEnd()
2625 
      raise x
2626 
    result = addBannerMap_result()
2627 
    result.read(self._iprot)
2628 
    self._iprot.readMessageEnd()
2629 
    if result.success is not None:
2630 
      return result.success
2631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2632 
 
8579 kshitij.so 2633 
  def updateBannerMap(self, bannerMap):
2634 
    """
2635 
    Parameters:
2636 
     - bannerMap
2637 
    """
2638 
    self.send_updateBannerMap(bannerMap)
2639 
    return self.recv_updateBannerMap()
2640 
 
2641 
  def send_updateBannerMap(self, bannerMap):
2642 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2643 
    args = updateBannerMap_args()
2644 
    args.bannerMap = bannerMap
2645 
    args.write(self._oprot)
2646 
    self._oprot.writeMessageEnd()
2647 
    self._oprot.trans.flush()
2648 
 
2649 
  def recv_updateBannerMap(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 = updateBannerMap_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, "updateBannerMap failed: unknown result");
2662 
 
6849 kshitij.so 2663 
  def deleteBannerMap(self, bannerName):
2664 
    """
2665 
    Parameters:
2666 
     - bannerName
2667 
    """
2668 
    self.send_deleteBannerMap(bannerName)
2669 
    return self.recv_deleteBannerMap()
2670 
 
2671 
  def send_deleteBannerMap(self, bannerName):
2672 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2673 
    args = deleteBannerMap_args()
2674 
    args.bannerName = bannerName
2675 
    args.write(self._oprot)
2676 
    self._oprot.writeMessageEnd()
2677 
    self._oprot.trans.flush()
2678 
 
2679 
  def recv_deleteBannerMap(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 = deleteBannerMap_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, "deleteBannerMap failed: unknown result");
2692 
 
9155 kshitij.so 2693 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2694 
    """
2695 
    Parameters:
2696 
     - bannerName
9155 kshitij.so 2697 
     - bannerType
6849 kshitij.so 2698 
    """
9155 kshitij.so 2699 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2700 
    return self.recv_getBannerMapDetails()
2701 
 
9155 kshitij.so 2702 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2703 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2704 
    args = getBannerMapDetails_args()
2705 
    args.bannerName = bannerName
9155 kshitij.so 2706 
    args.bannerType = bannerType
6849 kshitij.so 2707 
    args.write(self._oprot)
2708 
    self._oprot.writeMessageEnd()
2709 
    self._oprot.trans.flush()
2710 
 
2711 
  def recv_getBannerMapDetails(self, ):
2712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2713 
    if mtype == TMessageType.EXCEPTION:
2714 
      x = TApplicationException()
2715 
      x.read(self._iprot)
2716 
      self._iprot.readMessageEnd()
2717 
      raise x
2718 
    result = getBannerMapDetails_result()
2719 
    result.read(self._iprot)
2720 
    self._iprot.readMessageEnd()
2721 
    if result.success is not None:
2722 
      return result.success
2723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2724 
 
8579 kshitij.so 2725 
  def addBannerUri(self, bannerUriMappings):
2726 
    """
2727 
    Parameters:
2728 
     - bannerUriMappings
2729 
    """
2730 
    self.send_addBannerUri(bannerUriMappings)
2731 
    self.recv_addBannerUri()
2732 
 
2733 
  def send_addBannerUri(self, bannerUriMappings):
2734 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2735 
    args = addBannerUri_args()
2736 
    args.bannerUriMappings = bannerUriMappings
2737 
    args.write(self._oprot)
2738 
    self._oprot.writeMessageEnd()
2739 
    self._oprot.trans.flush()
2740 
 
2741 
  def recv_addBannerUri(self, ):
2742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2743 
    if mtype == TMessageType.EXCEPTION:
2744 
      x = TApplicationException()
2745 
      x.read(self._iprot)
2746 
      self._iprot.readMessageEnd()
2747 
      raise x
2748 
    result = addBannerUri_result()
2749 
    result.read(self._iprot)
2750 
    self._iprot.readMessageEnd()
2751 
    return
2752 
 
9155 kshitij.so 2753 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2754 
    """
2755 
    Parameters:
2756 
     - bannerName
9155 kshitij.so 2757 
     - bannerType
8579 kshitij.so 2758 
    """
9155 kshitij.so 2759 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2760 
    return self.recv_getUriMapping()
2761 
 
9155 kshitij.so 2762 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2763 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2764 
    args = getUriMapping_args()
2765 
    args.bannerName = bannerName
9155 kshitij.so 2766 
    args.bannerType = bannerType
8579 kshitij.so 2767 
    args.write(self._oprot)
2768 
    self._oprot.writeMessageEnd()
2769 
    self._oprot.trans.flush()
2770 
 
2771 
  def recv_getUriMapping(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 = getUriMapping_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, "getUriMapping failed: unknown result");
2784 
 
2785 
  def addCampaign(self, campaign):
2786 
    """
2787 
    Parameters:
2788 
     - campaign
2789 
    """
2790 
    self.send_addCampaign(campaign)
2791 
    self.recv_addCampaign()
2792 
 
2793 
  def send_addCampaign(self, campaign):
2794 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2795 
    args = addCampaign_args()
2796 
    args.campaign = campaign
2797 
    args.write(self._oprot)
2798 
    self._oprot.writeMessageEnd()
2799 
    self._oprot.trans.flush()
2800 
 
2801 
  def recv_addCampaign(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 = addCampaign_result()
2809 
    result.read(self._iprot)
2810 
    self._iprot.readMessageEnd()
2811 
    return
2812 
 
2813 
  def getCampaigns(self, campaignName):
2814 
    """
2815 
    Parameters:
2816 
     - campaignName
2817 
    """
2818 
    self.send_getCampaigns(campaignName)
2819 
    return self.recv_getCampaigns()
2820 
 
2821 
  def send_getCampaigns(self, campaignName):
2822 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2823 
    args = getCampaigns_args()
2824 
    args.campaignName = campaignName
2825 
    args.write(self._oprot)
2826 
    self._oprot.writeMessageEnd()
2827 
    self._oprot.trans.flush()
2828 
 
2829 
  def recv_getCampaigns(self, ):
2830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2831 
    if mtype == TMessageType.EXCEPTION:
2832 
      x = TApplicationException()
2833 
      x.read(self._iprot)
2834 
      self._iprot.readMessageEnd()
2835 
      raise x
2836 
    result = getCampaigns_result()
2837 
    result.read(self._iprot)
2838 
    self._iprot.readMessageEnd()
2839 
    if result.success is not None:
2840 
      return result.success
2841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2842 
 
2843 
  def deleteCampaign(self, campaignId):
2844 
    """
2845 
    Parameters:
2846 
     - campaignId
2847 
    """
2848 
    self.send_deleteCampaign(campaignId)
2849 
    self.recv_deleteCampaign()
2850 
 
2851 
  def send_deleteCampaign(self, campaignId):
2852 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2853 
    args = deleteCampaign_args()
2854 
    args.campaignId = campaignId
2855 
    args.write(self._oprot)
2856 
    self._oprot.writeMessageEnd()
2857 
    self._oprot.trans.flush()
2858 
 
2859 
  def recv_deleteCampaign(self, ):
2860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2861 
    if mtype == TMessageType.EXCEPTION:
2862 
      x = TApplicationException()
2863 
      x.read(self._iprot)
2864 
      self._iprot.readMessageEnd()
2865 
      raise x
2866 
    result = deleteCampaign_result()
2867 
    result.read(self._iprot)
2868 
    self._iprot.readMessageEnd()
2869 
    return
2870 
 
2871 
  def getAllCampaigns(self, ):
2872 
    self.send_getAllCampaigns()
2873 
    return self.recv_getAllCampaigns()
2874 
 
2875 
  def send_getAllCampaigns(self, ):
2876 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2877 
    args = getAllCampaigns_args()
2878 
    args.write(self._oprot)
2879 
    self._oprot.writeMessageEnd()
2880 
    self._oprot.trans.flush()
2881 
 
2882 
  def recv_getAllCampaigns(self, ):
2883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2884 
    if mtype == TMessageType.EXCEPTION:
2885 
      x = TApplicationException()
2886 
      x.read(self._iprot)
2887 
      self._iprot.readMessageEnd()
2888 
      raise x
2889 
    result = getAllCampaigns_result()
2890 
    result.read(self._iprot)
2891 
    self._iprot.readMessageEnd()
2892 
    if result.success is not None:
2893 
      return result.success
2894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2895 
 
9155 kshitij.so 2896 
  def getActiveBannersForMobileSite(self, ):
2897 
    self.send_getActiveBannersForMobileSite()
2898 
    return self.recv_getActiveBannersForMobileSite()
2899 
 
2900 
  def send_getActiveBannersForMobileSite(self, ):
2901 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2902 
    args = getActiveBannersForMobileSite_args()
2903 
    args.write(self._oprot)
2904 
    self._oprot.writeMessageEnd()
2905 
    self._oprot.trans.flush()
2906 
 
2907 
  def recv_getActiveBannersForMobileSite(self, ):
2908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2909 
    if mtype == TMessageType.EXCEPTION:
2910 
      x = TApplicationException()
2911 
      x.read(self._iprot)
2912 
      self._iprot.readMessageEnd()
2913 
      raise x
2914 
    result = getActiveBannersForMobileSite_result()
2915 
    result.read(self._iprot)
2916 
    self._iprot.readMessageEnd()
2917 
    if result.success is not None:
2918 
      return result.success
2919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2920 
 
5944 mandeep.dh 2921 
  def deleteSimilarItem(self, itemId, catalogItemId):
2922 
    """
2923 
    Delete similar item.
2924 
 
2925 
    Parameters:
2926 
     - itemId
2927 
     - catalogItemId
2928 
    """
2929 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2930 
    return self.recv_deleteSimilarItem()
2931 
 
2932 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2933 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2934 
    args = deleteSimilarItem_args()
2935 
    args.itemId = itemId
2936 
    args.catalogItemId = catalogItemId
2937 
    args.write(self._oprot)
2938 
    self._oprot.writeMessageEnd()
2939 
    self._oprot.trans.flush()
2940 
 
2941 
  def recv_deleteSimilarItem(self, ):
2942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2943 
    if mtype == TMessageType.EXCEPTION:
2944 
      x = TApplicationException()
2945 
      x.read(self._iprot)
2946 
      self._iprot.readMessageEnd()
2947 
      raise x
2948 
    result = deleteSimilarItem_result()
2949 
    result.read(self._iprot)
2950 
    self._iprot.readMessageEnd()
2951 
    if result.success is not None:
2952 
      return result.success
2953 
    if result.cex is not None:
2954 
      raise result.cex
2955 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2956 
 
2957 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2958 
    """
2959 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2960 
    If yes, returns the itemId else returns 0
2961 
 
2962 
    Parameters:
2963 
     - brand
2964 
     - modelNumber
2965 
     - modelName
2966 
     - color
2967 
    """
2968 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2969 
    return self.recv_checkSimilarItem()
2970 
 
2971 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2972 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2973 
    args = checkSimilarItem_args()
2974 
    args.brand = brand
2975 
    args.modelNumber = modelNumber
2976 
    args.modelName = modelName
2977 
    args.color = color
2978 
    args.write(self._oprot)
2979 
    self._oprot.writeMessageEnd()
2980 
    self._oprot.trans.flush()
2981 
 
2982 
  def recv_checkSimilarItem(self, ):
2983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2984 
    if mtype == TMessageType.EXCEPTION:
2985 
      x = TApplicationException()
2986 
      x.read(self._iprot)
2987 
      self._iprot.readMessageEnd()
2988 
      raise x
2989 
    result = checkSimilarItem_result()
2990 
    result.read(self._iprot)
2991 
    self._iprot.readMessageEnd()
2992 
    if result.success is not None:
2993 
      return result.success
2994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2995 
 
2996 
  def validateRiskyStatus(self, itemId):
2997 
    """
2998 
    Check wether item is risky and change status if inventory is not available for risky items
2999 
 
3000 
    Parameters:
3001 
     - itemId
3002 
    """
3003 
    self.send_validateRiskyStatus(itemId)
3004 
    self.recv_validateRiskyStatus()
3005 
 
3006 
  def send_validateRiskyStatus(self, itemId):
3007 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
3008 
    args = validateRiskyStatus_args()
3009 
    args.itemId = itemId
3010 
    args.write(self._oprot)
3011 
    self._oprot.writeMessageEnd()
3012 
    self._oprot.trans.flush()
3013 
 
3014 
  def recv_validateRiskyStatus(self, ):
3015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3016 
    if mtype == TMessageType.EXCEPTION:
3017 
      x = TApplicationException()
3018 
      x.read(self._iprot)
3019 
      self._iprot.readMessageEnd()
3020 
      raise x
3021 
    result = validateRiskyStatus_result()
3022 
    result.read(self._iprot)
3023 
    self._iprot.readMessageEnd()
3024 
    return
3025 
 
3026 
  def changeItemRiskyFlag(self, itemId, risky):
3027 
    """
3028 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
3029 
 
3030 
    Parameters:
3031 
     - itemId
3032 
     - risky
3033 
    """
3034 
    self.send_changeItemRiskyFlag(itemId, risky)
3035 
    self.recv_changeItemRiskyFlag()
3036 
 
3037 
  def send_changeItemRiskyFlag(self, itemId, risky):
3038 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
3039 
    args = changeItemRiskyFlag_args()
3040 
    args.itemId = itemId
3041 
    args.risky = risky
3042 
    args.write(self._oprot)
3043 
    self._oprot.writeMessageEnd()
3044 
    self._oprot.trans.flush()
3045 
 
3046 
  def recv_changeItemRiskyFlag(self, ):
3047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3048 
    if mtype == TMessageType.EXCEPTION:
3049 
      x = TApplicationException()
3050 
      x.read(self._iprot)
3051 
      self._iprot.readMessageEnd()
3052 
      raise x
3053 
    result = changeItemRiskyFlag_result()
3054 
    result.read(self._iprot)
3055 
    self._iprot.readMessageEnd()
3056 
    return
3057 
 
3058 
  def getItemsByRiskyFlag(self, ):
3059 
    """
3060 
    Returns list of items marked as risky.
3061 
    """
3062 
    self.send_getItemsByRiskyFlag()
3063 
    return self.recv_getItemsByRiskyFlag()
3064 
 
3065 
  def send_getItemsByRiskyFlag(self, ):
3066 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
3067 
    args = getItemsByRiskyFlag_args()
3068 
    args.write(self._oprot)
3069 
    self._oprot.writeMessageEnd()
3070 
    self._oprot.trans.flush()
3071 
 
3072 
  def recv_getItemsByRiskyFlag(self, ):
3073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3074 
    if mtype == TMessageType.EXCEPTION:
3075 
      x = TApplicationException()
3076 
      x.read(self._iprot)
3077 
      self._iprot.readMessageEnd()
3078 
      raise x
3079 
    result = getItemsByRiskyFlag_result()
3080 
    result.read(self._iprot)
3081 
    self._iprot.readMessageEnd()
3082 
    if result.success is not None:
3083 
      return result.success
3084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
3085 
 
3086 
  def getItemsForMasterSheet(self, category, brand):
3087 
    """
3088 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3089 
 
3090 
    Parameters:
3091 
     - category
3092 
     - brand
3093 
    """
3094 
    self.send_getItemsForMasterSheet(category, brand)
3095 
    return self.recv_getItemsForMasterSheet()
3096 
 
3097 
  def send_getItemsForMasterSheet(self, category, brand):
3098 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3099 
    args = getItemsForMasterSheet_args()
3100 
    args.category = category
3101 
    args.brand = brand
3102 
    args.write(self._oprot)
3103 
    self._oprot.writeMessageEnd()
3104 
    self._oprot.trans.flush()
3105 
 
3106 
  def recv_getItemsForMasterSheet(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 = getItemsForMasterSheet_result()
3114 
    result.read(self._iprot)
3115 
    self._iprot.readMessageEnd()
3116 
    if result.success is not None:
3117 
      return result.success
3118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3119 
 
3120 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3121 
    """
3122 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3123 
 
3124 
    Parameters:
3125 
     - beginIndex
3126 
     - totalItems
3127 
     - itemId
3128 
    """
3129 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3130 
    return self.recv_getSimilarItemsCatalogIds()
3131 
 
3132 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3133 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3134 
    args = getSimilarItemsCatalogIds_args()
3135 
    args.beginIndex = beginIndex
3136 
    args.totalItems = totalItems
3137 
    args.itemId = itemId
3138 
    args.write(self._oprot)
3139 
    self._oprot.writeMessageEnd()
3140 
    self._oprot.trans.flush()
3141 
 
3142 
  def recv_getSimilarItemsCatalogIds(self, ):
3143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3144 
    if mtype == TMessageType.EXCEPTION:
3145 
      x = TApplicationException()
3146 
      x.read(self._iprot)
3147 
      self._iprot.readMessageEnd()
3148 
      raise x
3149 
    result = getSimilarItemsCatalogIds_result()
3150 
    result.read(self._iprot)
3151 
    self._iprot.readMessageEnd()
3152 
    if result.success is not None:
3153 
      return result.success
3154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3155 
 
3156 
  def addProductNotification(self, itemId, email):
3157 
    """
3158 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3159 
 
3160 
    Parameters:
3161 
     - itemId
3162 
     - email
3163 
    """
3164 
    self.send_addProductNotification(itemId, email)
3165 
    return self.recv_addProductNotification()
3166 
 
3167 
  def send_addProductNotification(self, itemId, email):
3168 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3169 
    args = addProductNotification_args()
3170 
    args.itemId = itemId
3171 
    args.email = email
3172 
    args.write(self._oprot)
3173 
    self._oprot.writeMessageEnd()
3174 
    self._oprot.trans.flush()
3175 
 
3176 
  def recv_addProductNotification(self, ):
3177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3178 
    if mtype == TMessageType.EXCEPTION:
3179 
      x = TApplicationException()
3180 
      x.read(self._iprot)
3181 
      self._iprot.readMessageEnd()
3182 
      raise x
3183 
    result = addProductNotification_result()
3184 
    result.read(self._iprot)
3185 
    self._iprot.readMessageEnd()
3186 
    if result.success is not None:
3187 
      return result.success
3188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3189 
 
3190 
  def sendProductNotifications(self, ):
3191 
    """
3192 
    Send the product notifications to the users for items which has stock.
3193 
    """
3194 
    self.send_sendProductNotifications()
3195 
    return self.recv_sendProductNotifications()
3196 
 
3197 
  def send_sendProductNotifications(self, ):
3198 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3199 
    args = sendProductNotifications_args()
3200 
    args.write(self._oprot)
3201 
    self._oprot.writeMessageEnd()
3202 
    self._oprot.trans.flush()
3203 
 
3204 
  def recv_sendProductNotifications(self, ):
3205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3206 
    if mtype == TMessageType.EXCEPTION:
3207 
      x = TApplicationException()
3208 
      x.read(self._iprot)
3209 
      self._iprot.readMessageEnd()
3210 
      raise x
3211 
    result = sendProductNotifications_result()
3212 
    result.read(self._iprot)
3213 
    self._iprot.readMessageEnd()
3214 
    if result.success is not None:
3215 
      return result.success
3216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3217 
 
3218 
  def getAllBrandsByCategory(self, categoryId):
3219 
    """
3220 
    Returns list of brand names for a given category Id
3221 
 
3222 
    Parameters:
3223 
     - categoryId
3224 
    """
3225 
    self.send_getAllBrandsByCategory(categoryId)
3226 
    return self.recv_getAllBrandsByCategory()
3227 
 
3228 
  def send_getAllBrandsByCategory(self, categoryId):
3229 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3230 
    args = getAllBrandsByCategory_args()
3231 
    args.categoryId = categoryId
3232 
    args.write(self._oprot)
3233 
    self._oprot.writeMessageEnd()
3234 
    self._oprot.trans.flush()
3235 
 
3236 
  def recv_getAllBrandsByCategory(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 = getAllBrandsByCategory_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, "getAllBrandsByCategory failed: unknown result");
3249 
 
3250 
  def getAllBrands(self, ):
3251 
    """
3252 
    Returns list of brand names
3253 
    """
3254 
    self.send_getAllBrands()
3255 
    return self.recv_getAllBrands()
3256 
 
3257 
  def send_getAllBrands(self, ):
3258 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3259 
    args = getAllBrands_args()
3260 
    args.write(self._oprot)
3261 
    self._oprot.writeMessageEnd()
3262 
    self._oprot.trans.flush()
3263 
 
3264 
  def recv_getAllBrands(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 = getAllBrands_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, "getAllBrands failed: unknown result");
3277 
 
3278 
  def getAllSources(self, ):
3279 
    """
3280 
    Return list of all sources
3281 
    """
3282 
    self.send_getAllSources()
3283 
    return self.recv_getAllSources()
3284 
 
3285 
  def send_getAllSources(self, ):
3286 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3287 
    args = getAllSources_args()
3288 
    args.write(self._oprot)
3289 
    self._oprot.writeMessageEnd()
3290 
    self._oprot.trans.flush()
3291 
 
3292 
  def recv_getAllSources(self, ):
3293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3294 
    if mtype == TMessageType.EXCEPTION:
3295 
      x = TApplicationException()
3296 
      x.read(self._iprot)
3297 
      self._iprot.readMessageEnd()
3298 
      raise x
3299 
    result = getAllSources_result()
3300 
    result.read(self._iprot)
3301 
    self._iprot.readMessageEnd()
3302 
    if result.success is not None:
3303 
      return result.success
3304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3305 
 
3306 
  def getItemPricingBySource(self, itemId, sourceId):
3307 
    """
3308 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3309 
 
3310 
    Parameters:
3311 
     - itemId
3312 
     - sourceId
3313 
    """
3314 
    self.send_getItemPricingBySource(itemId, sourceId)
3315 
    return self.recv_getItemPricingBySource()
3316 
 
3317 
  def send_getItemPricingBySource(self, itemId, sourceId):
3318 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3319 
    args = getItemPricingBySource_args()
3320 
    args.itemId = itemId
3321 
    args.sourceId = sourceId
3322 
    args.write(self._oprot)
3323 
    self._oprot.writeMessageEnd()
3324 
    self._oprot.trans.flush()
3325 
 
3326 
  def recv_getItemPricingBySource(self, ):
3327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3328 
    if mtype == TMessageType.EXCEPTION:
3329 
      x = TApplicationException()
3330 
      x.read(self._iprot)
3331 
      self._iprot.readMessageEnd()
3332 
      raise x
3333 
    result = getItemPricingBySource_result()
3334 
    result.read(self._iprot)
3335 
    self._iprot.readMessageEnd()
3336 
    if result.success is not None:
3337 
      return result.success
3338 
    if result.cex is not None:
3339 
      raise result.cex
3340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3341 
 
3342 
  def addSourceItemPricing(self, sourceItemPricing):
3343 
    """
3344 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3345 
    If item is not found or source is not found, it will throw exception.
3346 
 
3347 
    Parameters:
3348 
     - sourceItemPricing
3349 
    """
3350 
    self.send_addSourceItemPricing(sourceItemPricing)
3351 
    self.recv_addSourceItemPricing()
3352 
 
3353 
  def send_addSourceItemPricing(self, sourceItemPricing):
3354 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3355 
    args = addSourceItemPricing_args()
3356 
    args.sourceItemPricing = sourceItemPricing
3357 
    args.write(self._oprot)
3358 
    self._oprot.writeMessageEnd()
3359 
    self._oprot.trans.flush()
3360 
 
3361 
  def recv_addSourceItemPricing(self, ):
3362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3363 
    if mtype == TMessageType.EXCEPTION:
3364 
      x = TApplicationException()
3365 
      x.read(self._iprot)
3366 
      self._iprot.readMessageEnd()
3367 
      raise x
3368 
    result = addSourceItemPricing_result()
3369 
    result.read(self._iprot)
3370 
    self._iprot.readMessageEnd()
3371 
    if result.cex is not None:
3372 
      raise result.cex
3373 
    return
3374 
 
3375 
  def getAllSourcePricing(self, itemId):
3376 
    """
3377 
    Returns the list of source pricing information of an item.
3378 
    Raises an exception if item not found corresponding to itemId
3379 
 
3380 
    Parameters:
3381 
     - itemId
3382 
    """
3383 
    self.send_getAllSourcePricing(itemId)
3384 
    return self.recv_getAllSourcePricing()
3385 
 
3386 
  def send_getAllSourcePricing(self, itemId):
3387 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3388 
    args = getAllSourcePricing_args()
3389 
    args.itemId = itemId
3390 
    args.write(self._oprot)
3391 
    self._oprot.writeMessageEnd()
3392 
    self._oprot.trans.flush()
3393 
 
3394 
  def recv_getAllSourcePricing(self, ):
3395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3396 
    if mtype == TMessageType.EXCEPTION:
3397 
      x = TApplicationException()
3398 
      x.read(self._iprot)
3399 
      self._iprot.readMessageEnd()
3400 
      raise x
3401 
    result = getAllSourcePricing_result()
3402 
    result.read(self._iprot)
3403 
    self._iprot.readMessageEnd()
3404 
    if result.success is not None:
3405 
      return result.success
3406 
    if result.cex is not None:
3407 
      raise result.cex
3408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3409 
 
3410 
  def getItemForSource(self, item_id, sourceId):
3411 
    """
3412 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3413 
 
3414 
    Parameters:
3415 
     - item_id
3416 
     - sourceId
3417 
    """
3418 
    self.send_getItemForSource(item_id, sourceId)
3419 
    return self.recv_getItemForSource()
3420 
 
3421 
  def send_getItemForSource(self, item_id, sourceId):
3422 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3423 
    args = getItemForSource_args()
3424 
    args.item_id = item_id
3425 
    args.sourceId = sourceId
3426 
    args.write(self._oprot)
3427 
    self._oprot.writeMessageEnd()
3428 
    self._oprot.trans.flush()
3429 
 
3430 
  def recv_getItemForSource(self, ):
3431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3432 
    if mtype == TMessageType.EXCEPTION:
3433 
      x = TApplicationException()
3434 
      x.read(self._iprot)
3435 
      self._iprot.readMessageEnd()
3436 
      raise x
3437 
    result = getItemForSource_result()
3438 
    result.read(self._iprot)
3439 
    self._iprot.readMessageEnd()
3440 
    if result.success is not None:
3441 
      return result.success
3442 
    if result.cex is not None:
3443 
      raise result.cex
3444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3445 
 
3446 
  def searchItemsInRange(self, searchTerms, offset, limit):
3447 
    """
3448 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3449 
 
3450 
    Parameters:
3451 
     - searchTerms
3452 
     - offset
3453 
     - limit
3454 
    """
3455 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3456 
    return self.recv_searchItemsInRange()
3457 
 
3458 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3459 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3460 
    args = searchItemsInRange_args()
3461 
    args.searchTerms = searchTerms
3462 
    args.offset = offset
3463 
    args.limit = limit
3464 
    args.write(self._oprot)
3465 
    self._oprot.writeMessageEnd()
3466 
    self._oprot.trans.flush()
3467 
 
3468 
  def recv_searchItemsInRange(self, ):
3469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3470 
    if mtype == TMessageType.EXCEPTION:
3471 
      x = TApplicationException()
3472 
      x.read(self._iprot)
3473 
      self._iprot.readMessageEnd()
3474 
      raise x
3475 
    result = searchItemsInRange_result()
3476 
    result.read(self._iprot)
3477 
    self._iprot.readMessageEnd()
3478 
    if result.success is not None:
3479 
      return result.success
3480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3481 
 
3482 
  def getSearchResultCount(self, searchTerms):
3483 
    """
3484 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3485 
 
3486 
    Parameters:
3487 
     - searchTerms
3488 
    """
3489 
    self.send_getSearchResultCount(searchTerms)
3490 
    return self.recv_getSearchResultCount()
3491 
 
3492 
  def send_getSearchResultCount(self, searchTerms):
3493 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3494 
    args = getSearchResultCount_args()
3495 
    args.searchTerms = searchTerms
3496 
    args.write(self._oprot)
3497 
    self._oprot.writeMessageEnd()
3498 
    self._oprot.trans.flush()
3499 
 
3500 
  def recv_getSearchResultCount(self, ):
3501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3502 
    if mtype == TMessageType.EXCEPTION:
3503 
      x = TApplicationException()
3504 
      x.read(self._iprot)
3505 
      self._iprot.readMessageEnd()
3506 
      raise x
3507 
    result = getSearchResultCount_result()
3508 
    result.read(self._iprot)
3509 
    self._iprot.readMessageEnd()
3510 
    if result.success is not None:
3511 
      return result.success
3512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3513 
 
3514 
  def getProductNotifications(self, startDateTime):
3515 
    """
3516 
    Returns a list of product notifications added after a supplied datetime
3517 
 
3518 
    Parameters:
3519 
     - startDateTime
3520 
    """
3521 
    self.send_getProductNotifications(startDateTime)
3522 
    return self.recv_getProductNotifications()
3523 
 
3524 
  def send_getProductNotifications(self, startDateTime):
3525 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3526 
    args = getProductNotifications_args()
3527 
    args.startDateTime = startDateTime
3528 
    args.write(self._oprot)
3529 
    self._oprot.writeMessageEnd()
3530 
    self._oprot.trans.flush()
3531 
 
3532 
  def recv_getProductNotifications(self, ):
3533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3534 
    if mtype == TMessageType.EXCEPTION:
3535 
      x = TApplicationException()
3536 
      x.read(self._iprot)
3537 
      self._iprot.readMessageEnd()
3538 
      raise x
3539 
    result = getProductNotifications_result()
3540 
    result.read(self._iprot)
3541 
    self._iprot.readMessageEnd()
3542 
    if result.success is not None:
3543 
      return result.success
3544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3545 
 
7897 amar.kumar 3546 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3547 
    """
3548 
    Returns a list of count of requests for product notification against each item
3549 
 
3550 
    Parameters:
3551 
     - startDateTime
7897 amar.kumar 3552 
     - categoryId
5944 mandeep.dh 3553 
    """
7897 amar.kumar 3554 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3555 
    return self.recv_getProductNotificationRequestCount()
3556 
 
7897 amar.kumar 3557 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3558 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3559 
    args = getProductNotificationRequestCount_args()
3560 
    args.startDateTime = startDateTime
7897 amar.kumar 3561 
    args.categoryId = categoryId
5944 mandeep.dh 3562 
    args.write(self._oprot)
3563 
    self._oprot.writeMessageEnd()
3564 
    self._oprot.trans.flush()
3565 
 
3566 
  def recv_getProductNotificationRequestCount(self, ):
3567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3568 
    if mtype == TMessageType.EXCEPTION:
3569 
      x = TApplicationException()
3570 
      x.read(self._iprot)
3571 
      self._iprot.readMessageEnd()
3572 
      raise x
3573 
    result = getProductNotificationRequestCount_result()
3574 
    result.read(self._iprot)
3575 
    self._iprot.readMessageEnd()
3576 
    if result.success is not None:
3577 
      return result.success
3578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3579 
 
3580 
  def addAuthorizationLog(self, itemId, username, reason):
3581 
    """
3582 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3583 
 
3584 
    Parameters:
3585 
     - itemId
3586 
     - username
3587 
     - reason
3588 
    """
3589 
    self.send_addAuthorizationLog(itemId, username, reason)
3590 
    return self.recv_addAuthorizationLog()
3591 
 
3592 
  def send_addAuthorizationLog(self, itemId, username, reason):
3593 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3594 
    args = addAuthorizationLog_args()
3595 
    args.itemId = itemId
3596 
    args.username = username
3597 
    args.reason = reason
3598 
    args.write(self._oprot)
3599 
    self._oprot.writeMessageEnd()
3600 
    self._oprot.trans.flush()
3601 
 
3602 
  def recv_addAuthorizationLog(self, ):
3603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3604 
    if mtype == TMessageType.EXCEPTION:
3605 
      x = TApplicationException()
3606 
      x.read(self._iprot)
3607 
      self._iprot.readMessageEnd()
3608 
      raise x
3609 
    result = addAuthorizationLog_result()
3610 
    result.read(self._iprot)
3611 
    self._iprot.readMessageEnd()
3612 
    if result.success is not None:
3613 
      return result.success
3614 
    if result.cex is not None:
3615 
      raise result.cex
3616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3617 
 
3618 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3619 
    """
3620 
    Parameters:
3621 
     - catalog_item_id
3622 
     - voucherType
3623 
     - voucherAmount
3624 
    """
3625 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3626 
    return self.recv_addupdateVoucherForItem()
3627 
 
3628 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3629 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3630 
    args = addupdateVoucherForItem_args()
3631 
    args.catalog_item_id = catalog_item_id
3632 
    args.voucherType = voucherType
3633 
    args.voucherAmount = voucherAmount
3634 
    args.write(self._oprot)
3635 
    self._oprot.writeMessageEnd()
3636 
    self._oprot.trans.flush()
3637 
 
3638 
  def recv_addupdateVoucherForItem(self, ):
3639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3640 
    if mtype == TMessageType.EXCEPTION:
3641 
      x = TApplicationException()
3642 
      x.read(self._iprot)
3643 
      self._iprot.readMessageEnd()
3644 
      raise x
3645 
    result = addupdateVoucherForItem_result()
3646 
    result.read(self._iprot)
3647 
    self._iprot.readMessageEnd()
3648 
    if result.success is not None:
3649 
      return result.success
3650 
    if result.cex is not None:
3651 
      raise result.cex
3652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3653 
 
3654 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3655 
    """
3656 
    Parameters:
3657 
     - catalog_item_id
3658 
     - voucherType
3659 
    """
3660 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3661 
    return self.recv_deleteVoucherForItem()
3662 
 
3663 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3664 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3665 
    args = deleteVoucherForItem_args()
3666 
    args.catalog_item_id = catalog_item_id
3667 
    args.voucherType = voucherType
3668 
    args.write(self._oprot)
3669 
    self._oprot.writeMessageEnd()
3670 
    self._oprot.trans.flush()
3671 
 
3672 
  def recv_deleteVoucherForItem(self, ):
3673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3674 
    if mtype == TMessageType.EXCEPTION:
3675 
      x = TApplicationException()
3676 
      x.read(self._iprot)
3677 
      self._iprot.readMessageEnd()
3678 
      raise x
3679 
    result = deleteVoucherForItem_result()
3680 
    result.read(self._iprot)
3681 
    self._iprot.readMessageEnd()
3682 
    if result.success is not None:
3683 
      return result.success
3684 
    if result.cex is not None:
3685 
      raise result.cex
3686 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3687 
 
3688 
  def getVoucherAmount(self, itemId, voucherType):
3689 
    """
3690 
    Parameters:
3691 
     - itemId
3692 
     - voucherType
3693 
    """
3694 
    self.send_getVoucherAmount(itemId, voucherType)
3695 
    return self.recv_getVoucherAmount()
3696 
 
3697 
  def send_getVoucherAmount(self, itemId, voucherType):
3698 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3699 
    args = getVoucherAmount_args()
3700 
    args.itemId = itemId
3701 
    args.voucherType = voucherType
3702 
    args.write(self._oprot)
3703 
    self._oprot.writeMessageEnd()
3704 
    self._oprot.trans.flush()
3705 
 
3706 
  def recv_getVoucherAmount(self, ):
3707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3708 
    if mtype == TMessageType.EXCEPTION:
3709 
      x = TApplicationException()
3710 
      x.read(self._iprot)
3711 
      self._iprot.readMessageEnd()
3712 
      raise x
3713 
    result = getVoucherAmount_result()
3714 
    result.read(self._iprot)
3715 
    self._iprot.readMessageEnd()
3716 
    if result.success is not None:
3717 
      return result.success
3718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3719 
 
3720 
  def getAllItemVouchers(self, itemId):
3721 
    """
3722 
    Parameters:
3723 
     - itemId
3724 
    """
3725 
    self.send_getAllItemVouchers(itemId)
3726 
    return self.recv_getAllItemVouchers()
3727 
 
3728 
  def send_getAllItemVouchers(self, itemId):
3729 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3730 
    args = getAllItemVouchers_args()
3731 
    args.itemId = itemId
3732 
    args.write(self._oprot)
3733 
    self._oprot.writeMessageEnd()
3734 
    self._oprot.trans.flush()
3735 
 
3736 
  def recv_getAllItemVouchers(self, ):
3737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3738 
    if mtype == TMessageType.EXCEPTION:
3739 
      x = TApplicationException()
3740 
      x.read(self._iprot)
3741 
      self._iprot.readMessageEnd()
3742 
      raise x
3743 
    result = getAllItemVouchers_result()
3744 
    result.read(self._iprot)
3745 
    self._iprot.readMessageEnd()
3746 
    if result.success is not None:
3747 
      return result.success
3748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3749 
 
3750 
  def isValidCatalogItemId(self, catalog_item_id):
3751 
    """
3752 
    Parameters:
3753 
     - catalog_item_id
3754 
    """
3755 
    self.send_isValidCatalogItemId(catalog_item_id)
3756 
    return self.recv_isValidCatalogItemId()
3757 
 
3758 
  def send_isValidCatalogItemId(self, catalog_item_id):
3759 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3760 
    args = isValidCatalogItemId_args()
3761 
    args.catalog_item_id = catalog_item_id
3762 
    args.write(self._oprot)
3763 
    self._oprot.writeMessageEnd()
3764 
    self._oprot.trans.flush()
3765 
 
3766 
  def recv_isValidCatalogItemId(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 = isValidCatalogItemId_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, "isValidCatalogItemId failed: unknown result");
3779 
 
7330 amit.gupta 3780 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3781 
    """
3782 
    Parameters:
3783 
     - itemId
7330 amit.gupta 3784 
     - stateId
6039 amit.gupta 3785 
     - price
3786 
    """
7330 amit.gupta 3787 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3788 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3789 
 
7330 amit.gupta 3790 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3791 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3792 
    args = getVatPercentageForItem_args()
3793 
    args.itemId = itemId
7330 amit.gupta 3794 
    args.stateId = stateId
6039 amit.gupta 3795 
    args.price = price
3796 
    args.write(self._oprot)
3797 
    self._oprot.writeMessageEnd()
3798 
    self._oprot.trans.flush()
3799 
 
3800 
  def recv_getVatPercentageForItem(self, ):
3801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3802 
    if mtype == TMessageType.EXCEPTION:
3803 
      x = TApplicationException()
3804 
      x.read(self._iprot)
3805 
      self._iprot.readMessageEnd()
3806 
      raise x
3807 
    result = getVatPercentageForItem_result()
3808 
    result.read(self._iprot)
3809 
    self._iprot.readMessageEnd()
3810 
    if result.success is not None:
3811 
      return result.success
7340 amit.gupta 3812 
    if result.cex is not None:
3813 
      raise result.cex
6039 amit.gupta 3814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3815 
 
3816 
  def getVatAmountForItem(self, itemId, price):
3817 
    """
3818 
    Parameters:
3819 
     - itemId
3820 
     - price
3821 
    """
3822 
    self.send_getVatAmountForItem(itemId, price)
3823 
    return self.recv_getVatAmountForItem()
3824 
 
3825 
  def send_getVatAmountForItem(self, itemId, price):
3826 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3827 
    args = getVatAmountForItem_args()
3828 
    args.itemId = itemId
3829 
    args.price = price
3830 
    args.write(self._oprot)
3831 
    self._oprot.writeMessageEnd()
3832 
    self._oprot.trans.flush()
3833 
 
3834 
  def recv_getVatAmountForItem(self, ):
3835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3836 
    if mtype == TMessageType.EXCEPTION:
3837 
      x = TApplicationException()
3838 
      x.read(self._iprot)
3839 
      self._iprot.readMessageEnd()
3840 
      raise x
3841 
    result = getVatAmountForItem_result()
3842 
    result.read(self._iprot)
3843 
    self._iprot.readMessageEnd()
3844 
    if result.success is not None:
3845 
      return result.success
3846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3847 
 
6531 vikram.rag 3848 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3849 
    """
3850 
    Parameters:
3851 
     - offset
3852 
     - limit
3853 
    """
3854 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3855 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3856 
 
6531 vikram.rag 3857 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3858 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3859 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3860 
    args.offset = offset
3861 
    args.limit = limit
3862 
    args.write(self._oprot)
3863 
    self._oprot.writeMessageEnd()
3864 
    self._oprot.trans.flush()
3865 
 
3866 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3868 
    if mtype == TMessageType.EXCEPTION:
3869 
      x = TApplicationException()
3870 
      x.read(self._iprot)
3871 
      self._iprot.readMessageEnd()
3872 
      raise x
3873 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3874 
    result.read(self._iprot)
3875 
    self._iprot.readMessageEnd()
3876 
    if result.success is not None:
3877 
      return result.success
3878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3879 
 
6821 amar.kumar 3880 
  def getAllAliveItems(self, ):
3881 
    self.send_getAllAliveItems()
3882 
    return self.recv_getAllAliveItems()
3883 
 
3884 
  def send_getAllAliveItems(self, ):
3885 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3886 
    args = getAllAliveItems_args()
3887 
    args.write(self._oprot)
3888 
    self._oprot.writeMessageEnd()
3889 
    self._oprot.trans.flush()
3890 
 
3891 
  def recv_getAllAliveItems(self, ):
3892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3893 
    if mtype == TMessageType.EXCEPTION:
3894 
      x = TApplicationException()
3895 
      x.read(self._iprot)
3896 
      self._iprot.readMessageEnd()
3897 
      raise x
3898 
    result = getAllAliveItems_result()
3899 
    result.read(self._iprot)
3900 
    self._iprot.readMessageEnd()
3901 
    if result.success is not None:
3902 
      return result.success
3903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3904 
 
6921 anupam.sin 3905 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3906 
    """
3907 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3908 
 
6805 anupam.sin 3909 
    Parameters:
3910 
     - itemId
6921 anupam.sin 3911 
     - price
6805 anupam.sin 3912 
     - insurerId
3913 
     - quantity
3914 
    """
6921 anupam.sin 3915 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3916 
    return self.recv_getInsuranceAmount()
3917 
 
6921 anupam.sin 3918 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3919 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3920 
    args = getInsuranceAmount_args()
3921 
    args.itemId = itemId
6921 anupam.sin 3922 
    args.price = price
6805 anupam.sin 3923 
    args.insurerId = insurerId
3924 
    args.quantity = quantity
3925 
    args.write(self._oprot)
3926 
    self._oprot.writeMessageEnd()
3927 
    self._oprot.trans.flush()
3928 
 
3929 
  def recv_getInsuranceAmount(self, ):
3930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3931 
    if mtype == TMessageType.EXCEPTION:
3932 
      x = TApplicationException()
3933 
      x.read(self._iprot)
3934 
      self._iprot.readMessageEnd()
3935 
      raise x
3936 
    result = getInsuranceAmount_result()
3937 
    result.read(self._iprot)
3938 
    self._iprot.readMessageEnd()
3939 
    if result.success is not None:
3940 
      return result.success
3941 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3942 
 
3943 
  def getInsurer(self, insurerId):
3944 
    """
3945 
    Parameters:
3946 
     - insurerId
3947 
    """
3948 
    self.send_getInsurer(insurerId)
3949 
    return self.recv_getInsurer()
3950 
 
3951 
  def send_getInsurer(self, insurerId):
3952 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3953 
    args = getInsurer_args()
3954 
    args.insurerId = insurerId
3955 
    args.write(self._oprot)
3956 
    self._oprot.writeMessageEnd()
3957 
    self._oprot.trans.flush()
3958 
 
3959 
  def recv_getInsurer(self, ):
3960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3961 
    if mtype == TMessageType.EXCEPTION:
3962 
      x = TApplicationException()
3963 
      x.read(self._iprot)
3964 
      self._iprot.readMessageEnd()
3965 
      raise x
3966 
    result = getInsurer_result()
3967 
    result.read(self._iprot)
3968 
    self._iprot.readMessageEnd()
3969 
    if result.success is not None:
3970 
      return result.success
3971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3972 
 
6838 vikram.rag 3973 
  def getAllInsurers(self, ):
3974 
    self.send_getAllInsurers()
3975 
    return self.recv_getAllInsurers()
6805 anupam.sin 3976 
 
6838 vikram.rag 3977 
  def send_getAllInsurers(self, ):
3978 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3979 
    args = getAllInsurers_args()
3980 
    args.write(self._oprot)
3981 
    self._oprot.writeMessageEnd()
3982 
    self._oprot.trans.flush()
3983 
 
3984 
  def recv_getAllInsurers(self, ):
3985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3986 
    if mtype == TMessageType.EXCEPTION:
3987 
      x = TApplicationException()
3988 
      x.read(self._iprot)
3989 
      self._iprot.readMessageEnd()
3990 
      raise x
3991 
    result = getAllInsurers_result()
3992 
    result.read(self._iprot)
3993 
    self._iprot.readMessageEnd()
3994 
    if result.success is not None:
3995 
      return result.success
3996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3997 
 
6962 rajveer 3998 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3999 
    """
4000 
    Parameters:
4001 
     - insurerId
4002 
     - amount
4003 
    """
4004 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
4005 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 4006 
 
6962 rajveer 4007 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
4008 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
4009 
    args = updateInsuranceDeclaredAmount_args()
4010 
    args.insurerId = insurerId
4011 
    args.amount = amount
4012 
    args.write(self._oprot)
4013 
    self._oprot.writeMessageEnd()
4014 
    self._oprot.trans.flush()
4015 
 
4016 
  def recv_updateInsuranceDeclaredAmount(self, ):
4017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4018 
    if mtype == TMessageType.EXCEPTION:
4019 
      x = TApplicationException()
4020 
      x.read(self._iprot)
4021 
      self._iprot.readMessageEnd()
4022 
      raise x
4023 
    result = updateInsuranceDeclaredAmount_result()
4024 
    result.read(self._iprot)
4025 
    self._iprot.readMessageEnd()
4026 
    return
4027 
 
7190 amar.kumar 4028 
  def getFreebieForItem(self, itemId):
4029 
    """
4030 
    Parameters:
4031 
     - itemId
4032 
    """
4033 
    self.send_getFreebieForItem(itemId)
4034 
    return self.recv_getFreebieForItem()
6962 rajveer 4035 
 
7190 amar.kumar 4036 
  def send_getFreebieForItem(self, itemId):
4037 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
4038 
    args = getFreebieForItem_args()
4039 
    args.itemId = itemId
4040 
    args.write(self._oprot)
4041 
    self._oprot.writeMessageEnd()
4042 
    self._oprot.trans.flush()
4043 
 
4044 
  def recv_getFreebieForItem(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 = getFreebieForItem_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, "getFreebieForItem failed: unknown result");
4057 
 
4058 
  def addOrUpdateFreebieForItem(self, freebieItem):
4059 
    """
4060 
    Parameters:
4061 
     - freebieItem
4062 
    """
4063 
    self.send_addOrUpdateFreebieForItem(freebieItem)
4064 
    self.recv_addOrUpdateFreebieForItem()
4065 
 
4066 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
4067 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
4068 
    args = addOrUpdateFreebieForItem_args()
4069 
    args.freebieItem = freebieItem
4070 
    args.write(self._oprot)
4071 
    self._oprot.writeMessageEnd()
4072 
    self._oprot.trans.flush()
4073 
 
4074 
  def recv_addOrUpdateFreebieForItem(self, ):
4075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4076 
    if mtype == TMessageType.EXCEPTION:
4077 
      x = TApplicationException()
4078 
      x.read(self._iprot)
4079 
      self._iprot.readMessageEnd()
4080 
      raise x
4081 
    result = addOrUpdateFreebieForItem_result()
4082 
    result.read(self._iprot)
4083 
    self._iprot.readMessageEnd()
4084 
    return
4085 
 
7272 amit.gupta 4086 
  def addOrUpdateBrandInfo(self, brandInfo):
4087 
    """
4088 
    Parameters:
4089 
     - brandInfo
4090 
    """
4091 
    self.send_addOrUpdateBrandInfo(brandInfo)
4092 
    self.recv_addOrUpdateBrandInfo()
4093 
 
4094 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4095 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4096 
    args = addOrUpdateBrandInfo_args()
4097 
    args.brandInfo = brandInfo
4098 
    args.write(self._oprot)
4099 
    self._oprot.writeMessageEnd()
4100 
    self._oprot.trans.flush()
4101 
 
4102 
  def recv_addOrUpdateBrandInfo(self, ):
4103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4104 
    if mtype == TMessageType.EXCEPTION:
4105 
      x = TApplicationException()
4106 
      x.read(self._iprot)
4107 
      self._iprot.readMessageEnd()
4108 
      raise x
4109 
    result = addOrUpdateBrandInfo_result()
4110 
    result.read(self._iprot)
4111 
    self._iprot.readMessageEnd()
4112 
    return
4113 
 
4114 
  def getBrandInfo(self, ):
4115 
    self.send_getBrandInfo()
4116 
    return self.recv_getBrandInfo()
4117 
 
4118 
  def send_getBrandInfo(self, ):
4119 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4120 
    args = getBrandInfo_args()
4121 
    args.write(self._oprot)
4122 
    self._oprot.writeMessageEnd()
4123 
    self._oprot.trans.flush()
4124 
 
4125 
  def recv_getBrandInfo(self, ):
4126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4127 
    if mtype == TMessageType.EXCEPTION:
4128 
      x = TApplicationException()
4129 
      x.read(self._iprot)
4130 
      self._iprot.readMessageEnd()
4131 
      raise x
4132 
    result = getBrandInfo_result()
4133 
    result.read(self._iprot)
4134 
    self._iprot.readMessageEnd()
4135 
    if result.success is not None:
4136 
      return result.success
4137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4138 
 
7256 rajveer 4139 
  def getStorePricing(self, itemId):
4140 
    """
4141 
    Parameters:
4142 
     - itemId
4143 
    """
4144 
    self.send_getStorePricing(itemId)
4145 
    return self.recv_getStorePricing()
7190 amar.kumar 4146 
 
7256 rajveer 4147 
  def send_getStorePricing(self, itemId):
4148 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4149 
    args = getStorePricing_args()
4150 
    args.itemId = itemId
4151 
    args.write(self._oprot)
4152 
    self._oprot.writeMessageEnd()
4153 
    self._oprot.trans.flush()
4154 
 
4155 
  def recv_getStorePricing(self, ):
4156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4157 
    if mtype == TMessageType.EXCEPTION:
4158 
      x = TApplicationException()
4159 
      x.read(self._iprot)
4160 
      self._iprot.readMessageEnd()
4161 
      raise x
4162 
    result = getStorePricing_result()
4163 
    result.read(self._iprot)
4164 
    self._iprot.readMessageEnd()
4165 
    if result.success is not None:
4166 
      return result.success
4167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4168 
 
7306 rajveer 4169 
  def getStorePricings(self, itemIds):
4170 
    """
4171 
    Parameters:
4172 
     - itemIds
4173 
    """
4174 
    self.send_getStorePricings(itemIds)
4175 
    return self.recv_getStorePricings()
4176 
 
4177 
  def send_getStorePricings(self, itemIds):
4178 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4179 
    args = getStorePricings_args()
4180 
    args.itemIds = itemIds
4181 
    args.write(self._oprot)
4182 
    self._oprot.writeMessageEnd()
4183 
    self._oprot.trans.flush()
4184 
 
4185 
  def recv_getStorePricings(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 = getStorePricings_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, "getStorePricings failed: unknown result");
4198 
 
7382 rajveer 4199 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4200 
    """
4201 
    Parameters:
4202 
     - sp
7382 rajveer 4203 
     - allColors
7265 rajveer 4204 
    """
7382 rajveer 4205 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4206 
    self.recv_updateStorePricing()
7256 rajveer 4207 
 
7382 rajveer 4208 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4209 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4210 
    args = updateStorePricing_args()
4211 
    args.sp = sp
7382 rajveer 4212 
    args.allColors = allColors
7265 rajveer 4213 
    args.write(self._oprot)
4214 
    self._oprot.writeMessageEnd()
4215 
    self._oprot.trans.flush()
4216 
 
4217 
  def recv_updateStorePricing(self, ):
4218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4219 
    if mtype == TMessageType.EXCEPTION:
4220 
      x = TApplicationException()
4221 
      x.read(self._iprot)
4222 
      self._iprot.readMessageEnd()
4223 
      raise x
4224 
    result = updateStorePricing_result()
4225 
    result.read(self._iprot)
4226 
    self._iprot.readMessageEnd()
4227 
    return
4228 
 
7281 kshitij.so 4229 
  def getAllAmazonListedItems(self, ):
4230 
    self.send_getAllAmazonListedItems()
4231 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4232 
 
7281 kshitij.so 4233 
  def send_getAllAmazonListedItems(self, ):
4234 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4235 
    args = getAllAmazonListedItems_args()
4236 
    args.write(self._oprot)
4237 
    self._oprot.writeMessageEnd()
4238 
    self._oprot.trans.flush()
4239 
 
4240 
  def recv_getAllAmazonListedItems(self, ):
4241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4242 
    if mtype == TMessageType.EXCEPTION:
4243 
      x = TApplicationException()
4244 
      x.read(self._iprot)
4245 
      self._iprot.readMessageEnd()
4246 
      raise x
4247 
    result = getAllAmazonListedItems_result()
4248 
    result.read(self._iprot)
4249 
    self._iprot.readMessageEnd()
4250 
    if result.success is not None:
4251 
      return result.success
4252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4253 
 
8619 kshitij.so 4254 
  def searchAmazonItems(self, searchTerm, offset, limit):
4255 
    """
4256 
    Parameters:
4257 
     - searchTerm
4258 
     - offset
4259 
     - limit
4260 
    """
4261 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4262 
    return self.recv_searchAmazonItems()
4263 
 
4264 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4265 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4266 
    args = searchAmazonItems_args()
4267 
    args.searchTerm = searchTerm
4268 
    args.offset = offset
4269 
    args.limit = limit
4270 
    args.write(self._oprot)
4271 
    self._oprot.writeMessageEnd()
4272 
    self._oprot.trans.flush()
4273 
 
4274 
  def recv_searchAmazonItems(self, ):
4275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4276 
    if mtype == TMessageType.EXCEPTION:
4277 
      x = TApplicationException()
4278 
      x.read(self._iprot)
4279 
      self._iprot.readMessageEnd()
4280 
      raise x
4281 
    result = searchAmazonItems_result()
4282 
    result.read(self._iprot)
4283 
    self._iprot.readMessageEnd()
4284 
    if result.success is not None:
4285 
      return result.success
4286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4287 
 
4288 
  def getAmazonSearchResultCount(self, searchTerm):
4289 
    """
4290 
    Parameters:
4291 
     - searchTerm
4292 
    """
4293 
    self.send_getAmazonSearchResultCount(searchTerm)
4294 
    return self.recv_getAmazonSearchResultCount()
4295 
 
4296 
  def send_getAmazonSearchResultCount(self, searchTerm):
4297 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4298 
    args = getAmazonSearchResultCount_args()
4299 
    args.searchTerm = searchTerm
4300 
    args.write(self._oprot)
4301 
    self._oprot.writeMessageEnd()
4302 
    self._oprot.trans.flush()
4303 
 
4304 
  def recv_getAmazonSearchResultCount(self, ):
4305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4306 
    if mtype == TMessageType.EXCEPTION:
4307 
      x = TApplicationException()
4308 
      x.read(self._iprot)
4309 
      self._iprot.readMessageEnd()
4310 
      raise x
4311 
    result = getAmazonSearchResultCount_result()
4312 
    result.read(self._iprot)
4313 
    self._iprot.readMessageEnd()
4314 
    if result.success is not None:
4315 
      return result.success
4316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4317 
 
4318 
  def getCountForAmazonlistedItems(self, ):
4319 
    self.send_getCountForAmazonlistedItems()
4320 
    return self.recv_getCountForAmazonlistedItems()
4321 
 
4322 
  def send_getCountForAmazonlistedItems(self, ):
4323 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4324 
    args = getCountForAmazonlistedItems_args()
4325 
    args.write(self._oprot)
4326 
    self._oprot.writeMessageEnd()
4327 
    self._oprot.trans.flush()
4328 
 
4329 
  def recv_getCountForAmazonlistedItems(self, ):
4330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4331 
    if mtype == TMessageType.EXCEPTION:
4332 
      x = TApplicationException()
4333 
      x.read(self._iprot)
4334 
      self._iprot.readMessageEnd()
4335 
      raise x
4336 
    result = getCountForAmazonlistedItems_result()
4337 
    result.read(self._iprot)
4338 
    self._iprot.readMessageEnd()
4339 
    if result.success is not None:
4340 
      return result.success
4341 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4342 
 
7281 kshitij.so 4343 
  def getAmazonItemDetails(self, itemId):
4344 
    """
4345 
    Parameters:
4346 
     - itemId
4347 
    """
4348 
    self.send_getAmazonItemDetails(itemId)
4349 
    return self.recv_getAmazonItemDetails()
4350 
 
4351 
  def send_getAmazonItemDetails(self, itemId):
4352 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4353 
    args = getAmazonItemDetails_args()
4354 
    args.itemId = itemId
4355 
    args.write(self._oprot)
4356 
    self._oprot.writeMessageEnd()
4357 
    self._oprot.trans.flush()
4358 
 
4359 
  def recv_getAmazonItemDetails(self, ):
4360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4361 
    if mtype == TMessageType.EXCEPTION:
4362 
      x = TApplicationException()
4363 
      x.read(self._iprot)
4364 
      self._iprot.readMessageEnd()
4365 
      raise x
4366 
    result = getAmazonItemDetails_result()
4367 
    result.read(self._iprot)
4368 
    self._iprot.readMessageEnd()
4369 
    if result.success is not None:
4370 
      return result.success
4371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4372 
 
8168 kshitij.so 4373 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4374 
    """
4375 
    Parameters:
8168 kshitij.so 4376 
     - amazonlisted
7281 kshitij.so 4377 
    """
8168 kshitij.so 4378 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4379 
    self.recv_updateAmazonItemDetails()
4380 
 
8168 kshitij.so 4381 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4382 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4383 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4384 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4385 
    args.write(self._oprot)
4386 
    self._oprot.writeMessageEnd()
4387 
    self._oprot.trans.flush()
4388 
 
4389 
  def recv_updateAmazonItemDetails(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 = updateAmazonItemDetails_result()
4397 
    result.read(self._iprot)
4398 
    self._iprot.readMessageEnd()
4399 
    return
4400 
 
4401 
  def addAmazonItem(self, amazonlisted):
4402 
    """
4403 
    Parameters:
4404 
     - amazonlisted
4405 
    """
4406 
    self.send_addAmazonItem(amazonlisted)
4407 
    self.recv_addAmazonItem()
4408 
 
4409 
  def send_addAmazonItem(self, amazonlisted):
4410 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4411 
    args = addAmazonItem_args()
4412 
    args.amazonlisted = amazonlisted
4413 
    args.write(self._oprot)
4414 
    self._oprot.writeMessageEnd()
4415 
    self._oprot.trans.flush()
4416 
 
4417 
  def recv_addAmazonItem(self, ):
4418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4419 
    if mtype == TMessageType.EXCEPTION:
4420 
      x = TApplicationException()
4421 
      x.read(self._iprot)
4422 
      self._iprot.readMessageEnd()
4423 
      raise x
4424 
    result = addAmazonItem_result()
4425 
    result.read(self._iprot)
4426 
    self._iprot.readMessageEnd()
4427 
    return
4428 
 
7291 vikram.rag 4429 
  def getAsinItems(self, ):
4430 
    self.send_getAsinItems()
4431 
    return self.recv_getAsinItems()
7281 kshitij.so 4432 
 
7291 vikram.rag 4433 
  def send_getAsinItems(self, ):
4434 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4435 
    args = getAsinItems_args()
4436 
    args.write(self._oprot)
4437 
    self._oprot.writeMessageEnd()
4438 
    self._oprot.trans.flush()
4439 
 
4440 
  def recv_getAsinItems(self, ):
4441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4442 
    if mtype == TMessageType.EXCEPTION:
4443 
      x = TApplicationException()
4444 
      x.read(self._iprot)
4445 
      self._iprot.readMessageEnd()
4446 
      raise x
4447 
    result = getAsinItems_result()
4448 
    result.read(self._iprot)
4449 
    self._iprot.readMessageEnd()
4450 
    if result.success is not None:
4451 
      return result.success
4452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4453 
 
4454 
  def getAllFbaListedItems(self, ):
4455 
    self.send_getAllFbaListedItems()
4456 
    return self.recv_getAllFbaListedItems()
4457 
 
4458 
  def send_getAllFbaListedItems(self, ):
4459 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4460 
    args = getAllFbaListedItems_args()
4461 
    args.write(self._oprot)
4462 
    self._oprot.writeMessageEnd()
4463 
    self._oprot.trans.flush()
4464 
 
4465 
  def recv_getAllFbaListedItems(self, ):
4466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4467 
    if mtype == TMessageType.EXCEPTION:
4468 
      x = TApplicationException()
4469 
      x.read(self._iprot)
4470 
      self._iprot.readMessageEnd()
4471 
      raise x
4472 
    result = getAllFbaListedItems_result()
4473 
    result.read(self._iprot)
4474 
    self._iprot.readMessageEnd()
4475 
    if result.success is not None:
4476 
      return result.success
4477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4478 
 
4479 
  def getAllNonFbaListedItems(self, ):
4480 
    self.send_getAllNonFbaListedItems()
4481 
    return self.recv_getAllNonFbaListedItems()
4482 
 
4483 
  def send_getAllNonFbaListedItems(self, ):
4484 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4485 
    args = getAllNonFbaListedItems_args()
4486 
    args.write(self._oprot)
4487 
    self._oprot.writeMessageEnd()
4488 
    self._oprot.trans.flush()
4489 
 
4490 
  def recv_getAllNonFbaListedItems(self, ):
4491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4492 
    if mtype == TMessageType.EXCEPTION:
4493 
      x = TApplicationException()
4494 
      x.read(self._iprot)
4495 
      self._iprot.readMessageEnd()
4496 
      raise x
4497 
    result = getAllNonFbaListedItems_result()
4498 
    result.read(self._iprot)
4499 
    self._iprot.readMessageEnd()
4500 
    if result.success is not None:
4501 
      return result.success
4502 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4503 
 
7460 kshitij.so 4504 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4505 
    """
4506 
    Parameters:
4507 
     - itemId
4508 
     - holdInventory
4509 
     - defaultInventory
4510 
    """
4511 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4512 
    return self.recv_updateItemInventory()
7291 vikram.rag 4513 
 
7460 kshitij.so 4514 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4515 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4516 
    args = updateItemInventory_args()
4517 
    args.itemId = itemId
4518 
    args.holdInventory = holdInventory
4519 
    args.defaultInventory = defaultInventory
4520 
    args.write(self._oprot)
4521 
    self._oprot.writeMessageEnd()
4522 
    self._oprot.trans.flush()
4523 
 
4524 
  def recv_updateItemInventory(self, ):
4525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4526 
    if mtype == TMessageType.EXCEPTION:
4527 
      x = TApplicationException()
4528 
      x.read(self._iprot)
4529 
      self._iprot.readMessageEnd()
4530 
      raise x
4531 
    result = updateItemInventory_result()
4532 
    result.read(self._iprot)
4533 
    self._iprot.readMessageEnd()
4534 
    if result.success is not None:
4535 
      return result.success
4536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4537 
 
7770 kshitij.so 4538 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4539 
    """
4540 
    Parameters:
4541 
     - type
4542 
     - sku
4543 
     - timestamp
4544 
    """
4545 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4546 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4547 
 
7770 kshitij.so 4548 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4549 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4550 
    args = updateTimestampForAmazonFeeds_args()
4551 
    args.type = type
4552 
    args.sku = sku
4553 
    args.timestamp = timestamp
4554 
    args.write(self._oprot)
4555 
    self._oprot.writeMessageEnd()
4556 
    self._oprot.trans.flush()
4557 
 
4558 
  def recv_updateTimestampForAmazonFeeds(self, ):
4559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4560 
    if mtype == TMessageType.EXCEPTION:
4561 
      x = TApplicationException()
4562 
      x.read(self._iprot)
4563 
      self._iprot.readMessageEnd()
4564 
      raise x
4565 
    result = updateTimestampForAmazonFeeds_result()
4566 
    result.read(self._iprot)
4567 
    self._iprot.readMessageEnd()
4568 
    if result.success is not None:
4569 
      return result.success
4570 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4571 
 
7897 amar.kumar 4572 
  def getAllParentCategories(self, ):
4573 
    self.send_getAllParentCategories()
4574 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4575 
 
7897 amar.kumar 4576 
  def send_getAllParentCategories(self, ):
4577 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4578 
    args = getAllParentCategories_args()
4579 
    args.write(self._oprot)
4580 
    self._oprot.writeMessageEnd()
4581 
    self._oprot.trans.flush()
4582 
 
4583 
  def recv_getAllParentCategories(self, ):
4584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4585 
    if mtype == TMessageType.EXCEPTION:
4586 
      x = TApplicationException()
4587 
      x.read(self._iprot)
4588 
      self._iprot.readMessageEnd()
4589 
      raise x
4590 
    result = getAllParentCategories_result()
4591 
    result.read(self._iprot)
4592 
    self._iprot.readMessageEnd()
4593 
    if result.success is not None:
4594 
      return result.success
4595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4596 
 
7977 kshitij.so 4597 
  def addPageViewEvent(self, pageViewEvents):
4598 
    """
4599 
    Parameters:
4600 
     - pageViewEvents
4601 
    """
4602 
    self.send_addPageViewEvent(pageViewEvents)
4603 
    self.recv_addPageViewEvent()
7897 amar.kumar 4604 
 
7977 kshitij.so 4605 
  def send_addPageViewEvent(self, pageViewEvents):
4606 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4607 
    args = addPageViewEvent_args()
4608 
    args.pageViewEvents = pageViewEvents
4609 
    args.write(self._oprot)
4610 
    self._oprot.writeMessageEnd()
4611 
    self._oprot.trans.flush()
4612 
 
4613 
  def recv_addPageViewEvent(self, ):
4614 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4615 
    if mtype == TMessageType.EXCEPTION:
4616 
      x = TApplicationException()
4617 
      x.read(self._iprot)
4618 
      self._iprot.readMessageEnd()
4619 
      raise x
4620 
    result = addPageViewEvent_result()
4621 
    result.read(self._iprot)
4622 
    self._iprot.readMessageEnd()
4623 
    return
4624 
 
4625 
  def addCartEvent(self, cartEvents):
4626 
    """
4627 
    Parameters:
4628 
     - cartEvents
4629 
    """
4630 
    self.send_addCartEvent(cartEvents)
4631 
    self.recv_addCartEvent()
4632 
 
4633 
  def send_addCartEvent(self, cartEvents):
4634 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4635 
    args = addCartEvent_args()
4636 
    args.cartEvents = cartEvents
4637 
    args.write(self._oprot)
4638 
    self._oprot.writeMessageEnd()
4639 
    self._oprot.trans.flush()
4640 
 
4641 
  def recv_addCartEvent(self, ):
4642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4643 
    if mtype == TMessageType.EXCEPTION:
4644 
      x = TApplicationException()
4645 
      x.read(self._iprot)
4646 
      self._iprot.readMessageEnd()
4647 
      raise x
4648 
    result = addCartEvent_result()
4649 
    result.read(self._iprot)
4650 
    self._iprot.readMessageEnd()
4651 
    return
4652 
 
8182 amar.kumar 4653 
  def addEbayItem(self, ebayItem):
4654 
    """
4655 
    Parameters:
4656 
     - ebayItem
4657 
    """
4658 
    self.send_addEbayItem(ebayItem)
4659 
    self.recv_addEbayItem()
4660 
 
4661 
  def send_addEbayItem(self, ebayItem):
4662 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4663 
    args = addEbayItem_args()
4664 
    args.ebayItem = ebayItem
4665 
    args.write(self._oprot)
4666 
    self._oprot.writeMessageEnd()
4667 
    self._oprot.trans.flush()
4668 
 
4669 
  def recv_addEbayItem(self, ):
4670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4671 
    if mtype == TMessageType.EXCEPTION:
4672 
      x = TApplicationException()
4673 
      x.read(self._iprot)
4674 
      self._iprot.readMessageEnd()
4675 
      raise x
4676 
    result = addEbayItem_result()
4677 
    result.read(self._iprot)
4678 
    self._iprot.readMessageEnd()
4679 
    return
4680 
 
4681 
  def getEbayItem(self, listingId):
4682 
    """
4683 
    Parameters:
4684 
     - listingId
4685 
    """
4686 
    self.send_getEbayItem(listingId)
4687 
    return self.recv_getEbayItem()
4688 
 
4689 
  def send_getEbayItem(self, listingId):
4690 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4691 
    args = getEbayItem_args()
4692 
    args.listingId = listingId
4693 
    args.write(self._oprot)
4694 
    self._oprot.writeMessageEnd()
4695 
    self._oprot.trans.flush()
4696 
 
4697 
  def recv_getEbayItem(self, ):
4698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4699 
    if mtype == TMessageType.EXCEPTION:
4700 
      x = TApplicationException()
4701 
      x.read(self._iprot)
4702 
      self._iprot.readMessageEnd()
4703 
      raise x
4704 
    result = getEbayItem_result()
4705 
    result.read(self._iprot)
4706 
    self._iprot.readMessageEnd()
4707 
    if result.success is not None:
4708 
      return result.success
4709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4710 
 
4711 
  def updateEbayItem(self, ebayItem):
4712 
    """
4713 
    Parameters:
4714 
     - ebayItem
4715 
    """
4716 
    self.send_updateEbayItem(ebayItem)
4717 
    self.recv_updateEbayItem()
4718 
 
4719 
  def send_updateEbayItem(self, ebayItem):
4720 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4721 
    args = updateEbayItem_args()
4722 
    args.ebayItem = ebayItem
4723 
    args.write(self._oprot)
4724 
    self._oprot.writeMessageEnd()
4725 
    self._oprot.trans.flush()
4726 
 
4727 
  def recv_updateEbayItem(self, ):
4728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4729 
    if mtype == TMessageType.EXCEPTION:
4730 
      x = TApplicationException()
4731 
      x.read(self._iprot)
4732 
      self._iprot.readMessageEnd()
4733 
      raise x
4734 
    result = updateEbayItem_result()
4735 
    result.read(self._iprot)
4736 
    self._iprot.readMessageEnd()
4737 
    return
4738 
 
8139 kshitij.so 4739 
  def getAmazonListedItems(self, offset, limit):
4740 
    """
4741 
    Parameters:
4742 
     - offset
4743 
     - limit
4744 
    """
4745 
    self.send_getAmazonListedItems(offset, limit)
4746 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4747 
 
8139 kshitij.so 4748 
  def send_getAmazonListedItems(self, offset, limit):
4749 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4750 
    args = getAmazonListedItems_args()
4751 
    args.offset = offset
4752 
    args.limit = limit
4753 
    args.write(self._oprot)
4754 
    self._oprot.writeMessageEnd()
4755 
    self._oprot.trans.flush()
4756 
 
4757 
  def recv_getAmazonListedItems(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 = getAmazonListedItems_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, "getAmazonListedItems failed: unknown result");
4770 
 
8168 kshitij.so 4771 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4772 
    """
4773 
    Parameters:
4774 
     - amazonlisted
4775 
    """
4776 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4777 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4778 
 
8168 kshitij.so 4779 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4780 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4781 
    args = updateAmazonAttributesInBulk_args()
4782 
    args.amazonlisted = amazonlisted
4783 
    args.write(self._oprot)
4784 
    self._oprot.writeMessageEnd()
4785 
    self._oprot.trans.flush()
4786 
 
4787 
  def recv_updateAmazonAttributesInBulk(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 = updateAmazonAttributesInBulk_result()
4795 
    result.read(self._iprot)
4796 
    self._iprot.readMessageEnd()
4797 
    if result.success is not None:
4798 
      return result.success
4799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4800 
 
8379 vikram.rag 4801 
  def getAllItemstoListOnFba(self, ):
4802 
    self.send_getAllItemstoListOnFba()
4803 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4804 
 
8379 vikram.rag 4805 
  def send_getAllItemstoListOnFba(self, ):
4806 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4807 
    args = getAllItemstoListOnFba_args()
4808 
    args.write(self._oprot)
4809 
    self._oprot.writeMessageEnd()
4810 
    self._oprot.trans.flush()
4811 
 
4812 
  def recv_getAllItemstoListOnFba(self, ):
4813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4814 
    if mtype == TMessageType.EXCEPTION:
4815 
      x = TApplicationException()
4816 
      x.read(self._iprot)
4817 
      self._iprot.readMessageEnd()
4818 
      raise x
4819 
    result = getAllItemstoListOnFba_result()
4820 
    result.read(self._iprot)
4821 
    self._iprot.readMessageEnd()
4822 
    if result.success is not None:
4823 
      return result.success
4824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4825 
 
4826 
  def getAllItemstoListOnNonFba(self, ):
4827 
    self.send_getAllItemstoListOnNonFba()
4828 
    return self.recv_getAllItemstoListOnNonFba()
4829 
 
4830 
  def send_getAllItemstoListOnNonFba(self, ):
4831 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4832 
    args = getAllItemstoListOnNonFba_args()
4833 
    args.write(self._oprot)
4834 
    self._oprot.writeMessageEnd()
4835 
    self._oprot.trans.flush()
4836 
 
4837 
  def recv_getAllItemstoListOnNonFba(self, ):
4838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4839 
    if mtype == TMessageType.EXCEPTION:
4840 
      x = TApplicationException()
4841 
      x.read(self._iprot)
4842 
      self._iprot.readMessageEnd()
4843 
      raise x
4844 
    result = getAllItemstoListOnNonFba_result()
4845 
    result.read(self._iprot)
4846 
    self._iprot.readMessageEnd()
4847 
    if result.success is not None:
4848 
      return result.success
4849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4850 
 
8619 kshitij.so 4851 
  def updateAsin(self, item):
4852 
    """
4853 
    Parameters:
4854 
     - item
4855 
    """
4856 
    self.send_updateAsin(item)
4857 
    self.recv_updateAsin()
8616 vikram.rag 4858 
 
8619 kshitij.so 4859 
  def send_updateAsin(self, item):
4860 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4861 
    args = updateAsin_args()
4862 
    args.item = item
4863 
    args.write(self._oprot)
4864 
    self._oprot.writeMessageEnd()
4865 
    self._oprot.trans.flush()
4866 
 
4867 
  def recv_updateAsin(self, ):
4868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4869 
    if mtype == TMessageType.EXCEPTION:
4870 
      x = TApplicationException()
4871 
      x.read(self._iprot)
4872 
      self._iprot.readMessageEnd()
4873 
      raise x
4874 
    result = updateAsin_result()
4875 
    result.read(self._iprot)
4876 
    self._iprot.readMessageEnd()
4877 
    return
4878 
 
8739 vikram.rag 4879 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4880 
    """
4881 
    Parameters:
4882 
     - snapdealitem
4883 
    """
4884 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4885 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4886 
 
8739 vikram.rag 4887 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4888 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4889 
    args = addOrUpdateSnapdealItem_args()
4890 
    args.snapdealitem = snapdealitem
4891 
    args.write(self._oprot)
4892 
    self._oprot.writeMessageEnd()
4893 
    self._oprot.trans.flush()
4894 
 
4895 
  def recv_addOrUpdateSnapdealItem(self, ):
4896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4897 
    if mtype == TMessageType.EXCEPTION:
4898 
      x = TApplicationException()
4899 
      x.read(self._iprot)
4900 
      self._iprot.readMessageEnd()
4901 
      raise x
4902 
    result = addOrUpdateSnapdealItem_result()
4903 
    result.read(self._iprot)
4904 
    self._iprot.readMessageEnd()
4905 
    if result.success is not None:
4906 
      return result.success
4907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4908 
 
4909 
  def getSnapdealItem(self, item_id):
4910 
    """
4911 
    Parameters:
4912 
     - item_id
4913 
    """
4914 
    self.send_getSnapdealItem(item_id)
4915 
    return self.recv_getSnapdealItem()
4916 
 
4917 
  def send_getSnapdealItem(self, item_id):
4918 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4919 
    args = getSnapdealItem_args()
4920 
    args.item_id = item_id
4921 
    args.write(self._oprot)
4922 
    self._oprot.writeMessageEnd()
4923 
    self._oprot.trans.flush()
4924 
 
4925 
  def recv_getSnapdealItem(self, ):
4926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4927 
    if mtype == TMessageType.EXCEPTION:
4928 
      x = TApplicationException()
4929 
      x.read(self._iprot)
4930 
      self._iprot.readMessageEnd()
4931 
      raise x
4932 
    result = getSnapdealItem_result()
4933 
    result.read(self._iprot)
4934 
    self._iprot.readMessageEnd()
4935 
    if result.success is not None:
4936 
      return result.success
4937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4938 
 
9242 kshitij.so 4939 
  def getSnapdealItemDetails(self, item_id):
4940 
    """
4941 
    Parameters:
4942 
     - item_id
4943 
    """
4944 
    self.send_getSnapdealItemDetails(item_id)
4945 
    return self.recv_getSnapdealItemDetails()
4946 
 
4947 
  def send_getSnapdealItemDetails(self, item_id):
4948 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
4949 
    args = getSnapdealItemDetails_args()
4950 
    args.item_id = item_id
4951 
    args.write(self._oprot)
4952 
    self._oprot.writeMessageEnd()
4953 
    self._oprot.trans.flush()
4954 
 
4955 
  def recv_getSnapdealItemDetails(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 = getSnapdealItemDetails_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, "getSnapdealItemDetails failed: unknown result");
4968 
 
8739 vikram.rag 4969 
  def getAllSnapdealItems(self, ):
4970 
    self.send_getAllSnapdealItems()
4971 
    return self.recv_getAllSnapdealItems()
4972 
 
4973 
  def send_getAllSnapdealItems(self, ):
4974 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4975 
    args = getAllSnapdealItems_args()
4976 
    args.write(self._oprot)
4977 
    self._oprot.writeMessageEnd()
4978 
    self._oprot.trans.flush()
4979 
 
4980 
  def recv_getAllSnapdealItems(self, ):
4981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4982 
    if mtype == TMessageType.EXCEPTION:
4983 
      x = TApplicationException()
4984 
      x.read(self._iprot)
4985 
      self._iprot.readMessageEnd()
4986 
      raise x
4987 
    result = getAllSnapdealItems_result()
4988 
    result.read(self._iprot)
4989 
    self._iprot.readMessageEnd()
4990 
    if result.success is not None:
4991 
      return result.success
4992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4993 
 
9242 kshitij.so 4994 
  def getSnapdealItems(self, offset, limit):
4995 
    """
4996 
    Parameters:
4997 
     - offset
4998 
     - limit
4999 
    """
5000 
    self.send_getSnapdealItems(offset, limit)
5001 
    return self.recv_getSnapdealItems()
8739 vikram.rag 5002 
 
9242 kshitij.so 5003 
  def send_getSnapdealItems(self, offset, limit):
5004 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
5005 
    args = getSnapdealItems_args()
5006 
    args.offset = offset
5007 
    args.limit = limit
5008 
    args.write(self._oprot)
5009 
    self._oprot.writeMessageEnd()
5010 
    self._oprot.trans.flush()
5011 
 
5012 
  def recv_getSnapdealItems(self, ):
5013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5014 
    if mtype == TMessageType.EXCEPTION:
5015 
      x = TApplicationException()
5016 
      x.read(self._iprot)
5017 
      self._iprot.readMessageEnd()
5018 
      raise x
5019 
    result = getSnapdealItems_result()
5020 
    result.read(self._iprot)
5021 
    self._iprot.readMessageEnd()
5022 
    if result.success is not None:
5023 
      return result.success
5024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
5025 
 
5026 
  def searchSnapdealItems(self, searchTerm, offset, limit):
5027 
    """
5028 
    Parameters:
5029 
     - searchTerm
5030 
     - offset
5031 
     - limit
5032 
    """
5033 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
5034 
    return self.recv_searchSnapdealItems()
5035 
 
5036 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
5037 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
5038 
    args = searchSnapdealItems_args()
5039 
    args.searchTerm = searchTerm
5040 
    args.offset = offset
5041 
    args.limit = limit
5042 
    args.write(self._oprot)
5043 
    self._oprot.writeMessageEnd()
5044 
    self._oprot.trans.flush()
5045 
 
5046 
  def recv_searchSnapdealItems(self, ):
5047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5048 
    if mtype == TMessageType.EXCEPTION:
5049 
      x = TApplicationException()
5050 
      x.read(self._iprot)
5051 
      self._iprot.readMessageEnd()
5052 
      raise x
5053 
    result = searchSnapdealItems_result()
5054 
    result.read(self._iprot)
5055 
    self._iprot.readMessageEnd()
5056 
    if result.success is not None:
5057 
      return result.success
5058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
5059 
 
5060 
  def getCountForSnapdealItems(self, ):
5061 
    self.send_getCountForSnapdealItems()
5062 
    return self.recv_getCountForSnapdealItems()
5063 
 
5064 
  def send_getCountForSnapdealItems(self, ):
5065 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
5066 
    args = getCountForSnapdealItems_args()
5067 
    args.write(self._oprot)
5068 
    self._oprot.writeMessageEnd()
5069 
    self._oprot.trans.flush()
5070 
 
5071 
  def recv_getCountForSnapdealItems(self, ):
5072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5073 
    if mtype == TMessageType.EXCEPTION:
5074 
      x = TApplicationException()
5075 
      x.read(self._iprot)
5076 
      self._iprot.readMessageEnd()
5077 
      raise x
5078 
    result = getCountForSnapdealItems_result()
5079 
    result.read(self._iprot)
5080 
    self._iprot.readMessageEnd()
5081 
    if result.success is not None:
5082 
      return result.success
5083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5084 
 
5085 
  def getSnapdealSearchResultCount(self, searchTerm):
5086 
    """
5087 
    Parameters:
5088 
     - searchTerm
5089 
    """
5090 
    self.send_getSnapdealSearchResultCount(searchTerm)
5091 
    return self.recv_getSnapdealSearchResultCount()
5092 
 
5093 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5094 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5095 
    args = getSnapdealSearchResultCount_args()
5096 
    args.searchTerm = searchTerm
5097 
    args.write(self._oprot)
5098 
    self._oprot.writeMessageEnd()
5099 
    self._oprot.trans.flush()
5100 
 
5101 
  def recv_getSnapdealSearchResultCount(self, ):
5102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5103 
    if mtype == TMessageType.EXCEPTION:
5104 
      x = TApplicationException()
5105 
      x.read(self._iprot)
5106 
      self._iprot.readMessageEnd()
5107 
      raise x
5108 
    result = getSnapdealSearchResultCount_result()
5109 
    result.read(self._iprot)
5110 
    self._iprot.readMessageEnd()
5111 
    if result.success is not None:
5112 
      return result.success
5113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5114 
 
9299 kshitij.so 5115 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5116 
    """
5117 
    Parameters:
5118 
     - itemId
5119 
     - insurerType
5120 
    """
5121 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5122 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5123 
 
9299 kshitij.so 5124 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5125 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5126 
    args = getPrefferedInsurerForItem_args()
5127 
    args.itemId = itemId
5128 
    args.insurerType = insurerType
5129 
    args.write(self._oprot)
5130 
    self._oprot.writeMessageEnd()
5131 
    self._oprot.trans.flush()
5132 
 
5133 
  def recv_getPrefferedInsurerForItem(self, ):
5134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5135 
    if mtype == TMessageType.EXCEPTION:
5136 
      x = TApplicationException()
5137 
      x.read(self._iprot)
5138 
      self._iprot.readMessageEnd()
5139 
      raise x
5140 
    result = getPrefferedInsurerForItem_result()
5141 
    result.read(self._iprot)
5142 
    self._iprot.readMessageEnd()
5143 
    if result.success is not None:
5144 
      return result.success
5145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5146 
 
9456 vikram.rag 5147 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5148 
    """
5149 
    Parameters:
5150 
     - skuAtSnapdeal
5151 
    """
5152 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5153 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5154 
 
9456 vikram.rag 5155 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5156 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5157 
    args = getSnapdealItembySkuAtSnapdeal_args()
5158 
    args.skuAtSnapdeal = skuAtSnapdeal
5159 
    args.write(self._oprot)
5160 
    self._oprot.writeMessageEnd()
5161 
    self._oprot.trans.flush()
5162 
 
5163 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5165 
    if mtype == TMessageType.EXCEPTION:
5166 
      x = TApplicationException()
5167 
      x.read(self._iprot)
5168 
      self._iprot.readMessageEnd()
5169 
      raise x
5170 
    result = getSnapdealItembySkuAtSnapdeal_result()
5171 
    result.read(self._iprot)
5172 
    self._iprot.readMessageEnd()
5173 
    if result.success is not None:
5174 
      return result.success
5175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5176 
 
9621 manish.sha 5177 
  def getProductFeedSubmit(self, catalogItemId):
5178 
    """
5179 
    Parameters:
5180 
     - catalogItemId
5181 
    """
5182 
    self.send_getProductFeedSubmit(catalogItemId)
5183 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5184 
 
9621 manish.sha 5185 
  def send_getProductFeedSubmit(self, catalogItemId):
5186 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5187 
    args = getProductFeedSubmit_args()
5188 
    args.catalogItemId = catalogItemId
5189 
    args.write(self._oprot)
5190 
    self._oprot.writeMessageEnd()
5191 
    self._oprot.trans.flush()
5192 
 
5193 
  def recv_getProductFeedSubmit(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 = getProductFeedSubmit_result()
5201 
    result.read(self._iprot)
5202 
    self._iprot.readMessageEnd()
5203 
    if result.success is not None:
5204 
      return result.success
5205 
    if result.cex is not None:
5206 
      raise result.cex
5207 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5208 
 
5209 
  def addProductFeedSubmit(self, productFeedSubmit):
5210 
    """
5211 
    Parameters:
5212 
     - productFeedSubmit
5213 
    """
5214 
    self.send_addProductFeedSubmit(productFeedSubmit)
5215 
    return self.recv_addProductFeedSubmit()
5216 
 
5217 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5218 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5219 
    args = addProductFeedSubmit_args()
5220 
    args.productFeedSubmit = productFeedSubmit
5221 
    args.write(self._oprot)
5222 
    self._oprot.writeMessageEnd()
5223 
    self._oprot.trans.flush()
5224 
 
5225 
  def recv_addProductFeedSubmit(self, ):
5226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5227 
    if mtype == TMessageType.EXCEPTION:
5228 
      x = TApplicationException()
5229 
      x.read(self._iprot)
5230 
      self._iprot.readMessageEnd()
5231 
      raise x
5232 
    result = addProductFeedSubmit_result()
5233 
    result.read(self._iprot)
5234 
    self._iprot.readMessageEnd()
5235 
    if result.success is not None:
5236 
      return result.success
5237 
    if result.cex is not None:
5238 
      raise result.cex
5239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5240 
 
5241 
  def updateProductFeedSubmit(self, productFeedSubmit):
5242 
    """
5243 
    Parameters:
5244 
     - productFeedSubmit
5245 
    """
5246 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5247 
    return self.recv_updateProductFeedSubmit()
5248 
 
5249 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5250 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5251 
    args = updateProductFeedSubmit_args()
5252 
    args.productFeedSubmit = productFeedSubmit
5253 
    args.write(self._oprot)
5254 
    self._oprot.writeMessageEnd()
5255 
    self._oprot.trans.flush()
5256 
 
5257 
  def recv_updateProductFeedSubmit(self, ):
5258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5259 
    if mtype == TMessageType.EXCEPTION:
5260 
      x = TApplicationException()
5261 
      x.read(self._iprot)
5262 
      self._iprot.readMessageEnd()
5263 
      raise x
5264 
    result = updateProductFeedSubmit_result()
5265 
    result.read(self._iprot)
5266 
    self._iprot.readMessageEnd()
5267 
    if result.success is not None:
5268 
      return result.success
5269 
    if result.cex is not None:
5270 
      raise result.cex
5271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5272 
 
5273 
  def deleteProductFeedSubmit(self, catalogItemId):
5274 
    """
5275 
    Parameters:
5276 
     - catalogItemId
5277 
    """
5278 
    self.send_deleteProductFeedSubmit(catalogItemId)
5279 
    return self.recv_deleteProductFeedSubmit()
5280 
 
5281 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5282 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5283 
    args = deleteProductFeedSubmit_args()
5284 
    args.catalogItemId = catalogItemId
5285 
    args.write(self._oprot)
5286 
    self._oprot.writeMessageEnd()
5287 
    self._oprot.trans.flush()
5288 
 
5289 
  def recv_deleteProductFeedSubmit(self, ):
5290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5291 
    if mtype == TMessageType.EXCEPTION:
5292 
      x = TApplicationException()
5293 
      x.read(self._iprot)
5294 
      self._iprot.readMessageEnd()
5295 
      raise x
5296 
    result = deleteProductFeedSubmit_result()
5297 
    result.read(self._iprot)
5298 
    self._iprot.readMessageEnd()
5299 
    if result.success is not None:
5300 
      return result.success
5301 
    if result.cex is not None:
5302 
      raise result.cex
5303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5304 
 
5305 
  def getAllProductFeedSubmit(self, ):
5306 
    self.send_getAllProductFeedSubmit()
5307 
    return self.recv_getAllProductFeedSubmit()
5308 
 
5309 
  def send_getAllProductFeedSubmit(self, ):
5310 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5311 
    args = getAllProductFeedSubmit_args()
5312 
    args.write(self._oprot)
5313 
    self._oprot.writeMessageEnd()
5314 
    self._oprot.trans.flush()
5315 
 
5316 
  def recv_getAllProductFeedSubmit(self, ):
5317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5318 
    if mtype == TMessageType.EXCEPTION:
5319 
      x = TApplicationException()
5320 
      x.read(self._iprot)
5321 
      self._iprot.readMessageEnd()
5322 
      raise x
5323 
    result = getAllProductFeedSubmit_result()
5324 
    result.read(self._iprot)
5325 
    self._iprot.readMessageEnd()
5326 
    if result.success is not None:
5327 
      return result.success
5328 
    if result.cex is not None:
5329 
      raise result.cex
5330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5331 
 
9724 kshitij.so 5332 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5333 
    """
5334 
    Parameters:
5335 
     - itemId
5336 
     - sourceId
5337 
    """
5338 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5339 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5340 
 
9724 kshitij.so 5341 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5342 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5343 
    args = getMarketplacedetailsForItem_args()
5344 
    args.itemId = itemId
5345 
    args.sourceId = sourceId
5346 
    args.write(self._oprot)
5347 
    self._oprot.writeMessageEnd()
5348 
    self._oprot.trans.flush()
5349 
 
5350 
  def recv_getMarketplacedetailsForItem(self, ):
5351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5352 
    if mtype == TMessageType.EXCEPTION:
5353 
      x = TApplicationException()
5354 
      x.read(self._iprot)
5355 
      self._iprot.readMessageEnd()
5356 
      raise x
5357 
    result = getMarketplacedetailsForItem_result()
5358 
    result.read(self._iprot)
5359 
    self._iprot.readMessageEnd()
5360 
    if result.success is not None:
5361 
      return result.success
5362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5363 
 
5364 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5365 
    """
5366 
    Parameters:
5367 
     - marketPlaceItem
5368 
    """
5369 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5370 
    return self.recv_updateMarketplaceAttributesForItem()
5371 
 
5372 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5373 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5374 
    args = updateMarketplaceAttributesForItem_args()
5375 
    args.marketPlaceItem = marketPlaceItem
5376 
    args.write(self._oprot)
5377 
    self._oprot.writeMessageEnd()
5378 
    self._oprot.trans.flush()
5379 
 
5380 
  def recv_updateMarketplaceAttributesForItem(self, ):
5381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5382 
    if mtype == TMessageType.EXCEPTION:
5383 
      x = TApplicationException()
5384 
      x.read(self._iprot)
5385 
      self._iprot.readMessageEnd()
5386 
      raise x
5387 
    result = updateMarketplaceAttributesForItem_result()
5388 
    result.read(self._iprot)
5389 
    self._iprot.readMessageEnd()
5390 
    if result.success is not None:
5391 
      return result.success
5392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5393 
 
9779 kshitij.so 5394 
  def getCostingForMarketplace(self, source, item_id):
5395 
    """
5396 
    Parameters:
5397 
     - source
5398 
     - item_id
5399 
    """
5400 
    self.send_getCostingForMarketplace(source, item_id)
5401 
    return self.recv_getCostingForMarketplace()
5402 
 
5403 
  def send_getCostingForMarketplace(self, source, item_id):
5404 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5405 
    args = getCostingForMarketplace_args()
5406 
    args.source = source
5407 
    args.item_id = item_id
5408 
    args.write(self._oprot)
5409 
    self._oprot.writeMessageEnd()
5410 
    self._oprot.trans.flush()
5411 
 
5412 
  def recv_getCostingForMarketplace(self, ):
5413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5414 
    if mtype == TMessageType.EXCEPTION:
5415 
      x = TApplicationException()
5416 
      x.read(self._iprot)
5417 
      self._iprot.readMessageEnd()
5418 
      raise x
5419 
    result = getCostingForMarketplace_result()
5420 
    result.read(self._iprot)
5421 
    self._iprot.readMessageEnd()
5422 
    if result.success is not None:
5423 
      return result.success
5424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5425 
 
9776 vikram.rag 5426 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5427 
    """
5428 
    Parameters:
5429 
     - source
5430 
    """
5431 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5432 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5433 
 
9776 vikram.rag 5434 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5435 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5436 
    args = getMarketPlaceItemsForPriceUpdate_args()
5437 
    args.source = source
5438 
    args.write(self._oprot)
5439 
    self._oprot.writeMessageEnd()
5440 
    self._oprot.trans.flush()
5441 
 
5442 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5444 
    if mtype == TMessageType.EXCEPTION:
5445 
      x = TApplicationException()
5446 
      x.read(self._iprot)
5447 
      self._iprot.readMessageEnd()
5448 
      raise x
5449 
    result = getMarketPlaceItemsForPriceUpdate_result()
5450 
    result.read(self._iprot)
5451 
    self._iprot.readMessageEnd()
5452 
    if result.success is not None:
5453 
      return result.success
5454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5455 
 
9816 kshitij.so 5456 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5457 
    """
5458 
    Parameters:
5459 
     - skulist
5460 
     - timestamp
9816 kshitij.so 5461 
     - source
9776 vikram.rag 5462 
    """
9816 kshitij.so 5463 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5464 
    self.recv_updateMarketPlacePriceUpdateStatus()
5465 
 
9816 kshitij.so 5466 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5467 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5468 
    args = updateMarketPlacePriceUpdateStatus_args()
5469 
    args.skulist = skulist
5470 
    args.timestamp = timestamp
9816 kshitij.so 5471 
    args.source = source
9776 vikram.rag 5472 
    args.write(self._oprot)
5473 
    self._oprot.writeMessageEnd()
5474 
    self._oprot.trans.flush()
5475 
 
5476 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5478 
    if mtype == TMessageType.EXCEPTION:
5479 
      x = TApplicationException()
5480 
      x.read(self._iprot)
5481 
      self._iprot.readMessageEnd()
5482 
      raise x
5483 
    result = updateMarketPlacePriceUpdateStatus_result()
5484 
    result.read(self._iprot)
5485 
    self._iprot.readMessageEnd()
5486 
    return
5487 
 
9861 rajveer 5488 
  def updateItemHoldInventory(self, itemHoldMap):
5489 
    """
5490 
    Parameters:
5491 
     - itemHoldMap
5492 
    """
5493 
    self.send_updateItemHoldInventory(itemHoldMap)
5494 
    self.recv_updateItemHoldInventory()
9776 vikram.rag 5495 
 
9861 rajveer 5496 
  def send_updateItemHoldInventory(self, itemHoldMap):
5497 
    self._oprot.writeMessageBegin('updateItemHoldInventory', TMessageType.CALL, self._seqid)
5498 
    args = updateItemHoldInventory_args()
5499 
    args.itemHoldMap = itemHoldMap
5500 
    args.write(self._oprot)
5501 
    self._oprot.writeMessageEnd()
5502 
    self._oprot.trans.flush()
5503 
 
5504 
  def recv_updateItemHoldInventory(self, ):
5505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5506 
    if mtype == TMessageType.EXCEPTION:
5507 
      x = TApplicationException()
5508 
      x.read(self._iprot)
5509 
      self._iprot.readMessageEnd()
5510 
      raise x
5511 
    result = updateItemHoldInventory_result()
5512 
    result.read(self._iprot)
5513 
    self._iprot.readMessageEnd()
5514 
    return
5515 
 
9895 vikram.rag 5516 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5517 
    """
5518 
    Parameters:
5519 
     - item_id
5520 
     - vendor_id
5521 
     - nlc
5522 
    """
5523 
    self.send_updateNlcAtMarketplaces(item_id, vendor_id, nlc)
5524 
    self.recv_updateNlcAtMarketplaces()
9861 rajveer 5525 
 
9895 vikram.rag 5526 
  def send_updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5527 
    self._oprot.writeMessageBegin('updateNlcAtMarketplaces', TMessageType.CALL, self._seqid)
5528 
    args = updateNlcAtMarketplaces_args()
5529 
    args.item_id = item_id
5530 
    args.vendor_id = vendor_id
5531 
    args.nlc = nlc
5532 
    args.write(self._oprot)
5533 
    self._oprot.writeMessageEnd()
5534 
    self._oprot.trans.flush()
5535 
 
5536 
  def recv_updateNlcAtMarketplaces(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 = updateNlcAtMarketplaces_result()
5544 
    result.read(self._iprot)
5545 
    self._iprot.readMessageEnd()
5546 
    return
5547 
 
9945 vikram.rag 5548 
  def getAllFlipkartItems(self, ):
5549 
    self.send_getAllFlipkartItems()
5550 
    return self.recv_getAllFlipkartItems()
9895 vikram.rag 5551 
 
9945 vikram.rag 5552 
  def send_getAllFlipkartItems(self, ):
5553 
    self._oprot.writeMessageBegin('getAllFlipkartItems', TMessageType.CALL, self._seqid)
5554 
    args = getAllFlipkartItems_args()
5555 
    args.write(self._oprot)
5556 
    self._oprot.writeMessageEnd()
5557 
    self._oprot.trans.flush()
5558 
 
5559 
  def recv_getAllFlipkartItems(self, ):
5560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5561 
    if mtype == TMessageType.EXCEPTION:
5562 
      x = TApplicationException()
5563 
      x.read(self._iprot)
5564 
      self._iprot.readMessageEnd()
5565 
      raise x
5566 
    result = getAllFlipkartItems_result()
5567 
    result.read(self._iprot)
5568 
    self._iprot.readMessageEnd()
5569 
    if result.success is not None:
5570 
      return result.success
5571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartItems failed: unknown result");
5572 
 
10097 kshitij.so 5573 
  def addOrUpdateFlipkartItem(self, flipkartitem):
5574 
    """
5575 
    Parameters:
5576 
     - flipkartitem
5577 
    """
5578 
    self.send_addOrUpdateFlipkartItem(flipkartitem)
5579 
    return self.recv_addOrUpdateFlipkartItem()
9945 vikram.rag 5580 
 
10097 kshitij.so 5581 
  def send_addOrUpdateFlipkartItem(self, flipkartitem):
5582 
    self._oprot.writeMessageBegin('addOrUpdateFlipkartItem', TMessageType.CALL, self._seqid)
5583 
    args = addOrUpdateFlipkartItem_args()
5584 
    args.flipkartitem = flipkartitem
5585 
    args.write(self._oprot)
5586 
    self._oprot.writeMessageEnd()
5587 
    self._oprot.trans.flush()
5588 
 
5589 
  def recv_addOrUpdateFlipkartItem(self, ):
5590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5591 
    if mtype == TMessageType.EXCEPTION:
5592 
      x = TApplicationException()
5593 
      x.read(self._iprot)
5594 
      self._iprot.readMessageEnd()
5595 
      raise x
5596 
    result = addOrUpdateFlipkartItem_result()
5597 
    result.read(self._iprot)
5598 
    self._iprot.readMessageEnd()
5599 
    if result.success is not None:
5600 
      return result.success
5601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateFlipkartItem failed: unknown result");
5602 
 
5603 
  def getFlipkartItem(self, item_id):
5604 
    """
5605 
    Parameters:
5606 
     - item_id
5607 
    """
5608 
    self.send_getFlipkartItem(item_id)
5609 
    return self.recv_getFlipkartItem()
5610 
 
5611 
  def send_getFlipkartItem(self, item_id):
5612 
    self._oprot.writeMessageBegin('getFlipkartItem', TMessageType.CALL, self._seqid)
5613 
    args = getFlipkartItem_args()
5614 
    args.item_id = item_id
5615 
    args.write(self._oprot)
5616 
    self._oprot.writeMessageEnd()
5617 
    self._oprot.trans.flush()
5618 
 
5619 
  def recv_getFlipkartItem(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 = getFlipkartItem_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, "getFlipkartItem failed: unknown result");
5632 
 
5633 
  def getFlipkartItemDetails(self, item_id):
5634 
    """
5635 
    Parameters:
5636 
     - item_id
5637 
    """
5638 
    self.send_getFlipkartItemDetails(item_id)
5639 
    return self.recv_getFlipkartItemDetails()
5640 
 
5641 
  def send_getFlipkartItemDetails(self, item_id):
5642 
    self._oprot.writeMessageBegin('getFlipkartItemDetails', TMessageType.CALL, self._seqid)
5643 
    args = getFlipkartItemDetails_args()
5644 
    args.item_id = item_id
5645 
    args.write(self._oprot)
5646 
    self._oprot.writeMessageEnd()
5647 
    self._oprot.trans.flush()
5648 
 
5649 
  def recv_getFlipkartItemDetails(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 = getFlipkartItemDetails_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, "getFlipkartItemDetails failed: unknown result");
5662 
 
5663 
  def getFlipkartItems(self, offset, limit):
5664 
    """
5665 
    Parameters:
5666 
     - offset
5667 
     - limit
5668 
    """
5669 
    self.send_getFlipkartItems(offset, limit)
5670 
    return self.recv_getFlipkartItems()
5671 
 
5672 
  def send_getFlipkartItems(self, offset, limit):
5673 
    self._oprot.writeMessageBegin('getFlipkartItems', TMessageType.CALL, self._seqid)
5674 
    args = getFlipkartItems_args()
5675 
    args.offset = offset
5676 
    args.limit = limit
5677 
    args.write(self._oprot)
5678 
    self._oprot.writeMessageEnd()
5679 
    self._oprot.trans.flush()
5680 
 
5681 
  def recv_getFlipkartItems(self, ):
5682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5683 
    if mtype == TMessageType.EXCEPTION:
5684 
      x = TApplicationException()
5685 
      x.read(self._iprot)
5686 
      self._iprot.readMessageEnd()
5687 
      raise x
5688 
    result = getFlipkartItems_result()
5689 
    result.read(self._iprot)
5690 
    self._iprot.readMessageEnd()
5691 
    if result.success is not None:
5692 
      return result.success
5693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItems failed: unknown result");
5694 
 
5695 
  def searchFlipkartItems(self, searchTerm, offset, limit):
5696 
    """
5697 
    Parameters:
5698 
     - searchTerm
5699 
     - offset
5700 
     - limit
5701 
    """
5702 
    self.send_searchFlipkartItems(searchTerm, offset, limit)
5703 
    return self.recv_searchFlipkartItems()
5704 
 
5705 
  def send_searchFlipkartItems(self, searchTerm, offset, limit):
5706 
    self._oprot.writeMessageBegin('searchFlipkartItems', TMessageType.CALL, self._seqid)
5707 
    args = searchFlipkartItems_args()
5708 
    args.searchTerm = searchTerm
5709 
    args.offset = offset
5710 
    args.limit = limit
5711 
    args.write(self._oprot)
5712 
    self._oprot.writeMessageEnd()
5713 
    self._oprot.trans.flush()
5714 
 
5715 
  def recv_searchFlipkartItems(self, ):
5716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5717 
    if mtype == TMessageType.EXCEPTION:
5718 
      x = TApplicationException()
5719 
      x.read(self._iprot)
5720 
      self._iprot.readMessageEnd()
5721 
      raise x
5722 
    result = searchFlipkartItems_result()
5723 
    result.read(self._iprot)
5724 
    self._iprot.readMessageEnd()
5725 
    if result.success is not None:
5726 
      return result.success
5727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchFlipkartItems failed: unknown result");
5728 
 
5729 
  def getCountForFlipkartItems(self, ):
5730 
    self.send_getCountForFlipkartItems()
5731 
    return self.recv_getCountForFlipkartItems()
5732 
 
5733 
  def send_getCountForFlipkartItems(self, ):
5734 
    self._oprot.writeMessageBegin('getCountForFlipkartItems', TMessageType.CALL, self._seqid)
5735 
    args = getCountForFlipkartItems_args()
5736 
    args.write(self._oprot)
5737 
    self._oprot.writeMessageEnd()
5738 
    self._oprot.trans.flush()
5739 
 
5740 
  def recv_getCountForFlipkartItems(self, ):
5741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5742 
    if mtype == TMessageType.EXCEPTION:
5743 
      x = TApplicationException()
5744 
      x.read(self._iprot)
5745 
      self._iprot.readMessageEnd()
5746 
      raise x
5747 
    result = getCountForFlipkartItems_result()
5748 
    result.read(self._iprot)
5749 
    self._iprot.readMessageEnd()
5750 
    if result.success is not None:
5751 
      return result.success
5752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForFlipkartItems failed: unknown result");
5753 
 
5754 
  def getFlipkartSearchResultCount(self, searchTerm):
5755 
    """
5756 
    Parameters:
5757 
     - searchTerm
5758 
    """
5759 
    self.send_getFlipkartSearchResultCount(searchTerm)
5760 
    return self.recv_getFlipkartSearchResultCount()
5761 
 
5762 
  def send_getFlipkartSearchResultCount(self, searchTerm):
5763 
    self._oprot.writeMessageBegin('getFlipkartSearchResultCount', TMessageType.CALL, self._seqid)
5764 
    args = getFlipkartSearchResultCount_args()
5765 
    args.searchTerm = searchTerm
5766 
    args.write(self._oprot)
5767 
    self._oprot.writeMessageEnd()
5768 
    self._oprot.trans.flush()
5769 
 
5770 
  def recv_getFlipkartSearchResultCount(self, ):
5771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5772 
    if mtype == TMessageType.EXCEPTION:
5773 
      x = TApplicationException()
5774 
      x.read(self._iprot)
5775 
      self._iprot.readMessageEnd()
5776 
      raise x
5777 
    result = getFlipkartSearchResultCount_result()
5778 
    result.read(self._iprot)
5779 
    self._iprot.readMessageEnd()
5780 
    if result.success is not None:
5781 
      return result.success
5782 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartSearchResultCount failed: unknown result");
5783 
 
5784 
  def getAllFkItems(self, ):
5785 
    self.send_getAllFkItems()
5786 
    return self.recv_getAllFkItems()
5787 
 
5788 
  def send_getAllFkItems(self, ):
5789 
    self._oprot.writeMessageBegin('getAllFkItems', TMessageType.CALL, self._seqid)
5790 
    args = getAllFkItems_args()
5791 
    args.write(self._oprot)
5792 
    self._oprot.writeMessageEnd()
5793 
    self._oprot.trans.flush()
5794 
 
5795 
  def recv_getAllFkItems(self, ):
5796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5797 
    if mtype == TMessageType.EXCEPTION:
5798 
      x = TApplicationException()
5799 
      x.read(self._iprot)
5800 
      self._iprot.readMessageEnd()
5801 
      raise x
5802 
    result = getAllFkItems_result()
5803 
    result.read(self._iprot)
5804 
    self._iprot.readMessageEnd()
5805 
    if result.success is not None:
5806 
      return result.success
5807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFkItems failed: unknown result");
5808 
 
10140 vikram.rag 5809 
  def getFlipkartItemBySkyAtFlipkart(self, sku):
5810 
    """
5811 
    Parameters:
5812 
     - sku
5813 
    """
5814 
    self.send_getFlipkartItemBySkyAtFlipkart(sku)
5815 
    return self.recv_getFlipkartItemBySkyAtFlipkart()
10097 kshitij.so 5816 
 
10140 vikram.rag 5817 
  def send_getFlipkartItemBySkyAtFlipkart(self, sku):
5818 
    self._oprot.writeMessageBegin('getFlipkartItemBySkyAtFlipkart', TMessageType.CALL, self._seqid)
5819 
    args = getFlipkartItemBySkyAtFlipkart_args()
5820 
    args.sku = sku
5821 
    args.write(self._oprot)
5822 
    self._oprot.writeMessageEnd()
5823 
    self._oprot.trans.flush()
5824 
 
5825 
  def recv_getFlipkartItemBySkyAtFlipkart(self, ):
5826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5827 
    if mtype == TMessageType.EXCEPTION:
5828 
      x = TApplicationException()
5829 
      x.read(self._iprot)
5830 
      self._iprot.readMessageEnd()
5831 
      raise x
5832 
    result = getFlipkartItemBySkyAtFlipkart_result()
5833 
    result.read(self._iprot)
5834 
    self._iprot.readMessageEnd()
5835 
    if result.success is not None:
5836 
      return result.success
5837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemBySkyAtFlipkart failed: unknown result");
5838 
 
5839 
 
5944 mandeep.dh 5840 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
5841 
  def __init__(self, handler):
5842 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
5843 
    self._processMap["addItem"] = Processor.process_addItem
5844 
    self._processMap["updateItem"] = Processor.process_updateItem
5845 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 5846 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 5847 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
5848 
    self._processMap["startItemOn"] = Processor.process_startItemOn
5849 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
5850 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
5851 
    self._processMap["getItem"] = Processor.process_getItem
5852 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
5853 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
5854 
    self._processMap["getAllItems"] = Processor.process_getAllItems
5855 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
5856 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
5857 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
5858 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
5859 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
5860 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
5861 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
5862 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
5863 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
5864 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
5865 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
5866 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
5867 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
5868 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
5869 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
5870 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
5871 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
5872 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
5873 
    self._processMap["addCategory"] = Processor.process_addCategory
5874 
    self._processMap["getCategory"] = Processor.process_getCategory
5875 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
5876 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
5877 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 5878 
    self._processMap["addTag"] = Processor.process_addTag
5879 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
5880 
    self._processMap["deleteTag"] = Processor.process_deleteTag
5881 
    self._processMap["getAllTags"] = Processor.process_getAllTags
5882 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 5883 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 5884 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 5885 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 5886 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
5887 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
5888 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
5889 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 5890 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 5891 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 5892 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
5893 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 5894 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
5895 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
5896 
    self._processMap["addCampaign"] = Processor.process_addCampaign
5897 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
5898 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
5899 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 5900 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 5901 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
5902 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
5903 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
5904 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
5905 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
5906 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
5907 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
5908 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
5909 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
5910 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
5911 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
5912 
    self._processMap["getAllSources"] = Processor.process_getAllSources
5913 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
5914 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
5915 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
5916 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
5917 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
5918 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
5919 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
5920 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
5921 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
5922 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
5923 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
5924 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
5925 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
5926 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 5927 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
5928 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 5929 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 5930 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 5931 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
5932 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 5933 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 5934 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 5935 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
5936 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 5937 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
5938 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 5939 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 5940 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 5941 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 5942 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 5943 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
5944 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
5945 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 5946 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
5947 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
5948 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 5949 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
5950 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
5951 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 5952 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 5953 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 5954 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 5955 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
5956 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 5957 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
5958 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
5959 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 5960 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 5961 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 5962 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
5963 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 5964 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 5965 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
5966 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 5967 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 5968 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 5969 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
5970 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
5971 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
5972 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 5973 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 5974 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 5975 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
5976 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
5977 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
5978 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
5979 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 5980 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
5981 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 5982 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 5983 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
5984 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
9861 rajveer 5985 
    self._processMap["updateItemHoldInventory"] = Processor.process_updateItemHoldInventory
9895 vikram.rag 5986 
    self._processMap["updateNlcAtMarketplaces"] = Processor.process_updateNlcAtMarketplaces
9945 vikram.rag 5987 
    self._processMap["getAllFlipkartItems"] = Processor.process_getAllFlipkartItems
10097 kshitij.so 5988 
    self._processMap["addOrUpdateFlipkartItem"] = Processor.process_addOrUpdateFlipkartItem
5989 
    self._processMap["getFlipkartItem"] = Processor.process_getFlipkartItem
5990 
    self._processMap["getFlipkartItemDetails"] = Processor.process_getFlipkartItemDetails
5991 
    self._processMap["getFlipkartItems"] = Processor.process_getFlipkartItems
5992 
    self._processMap["searchFlipkartItems"] = Processor.process_searchFlipkartItems
5993 
    self._processMap["getCountForFlipkartItems"] = Processor.process_getCountForFlipkartItems
5994 
    self._processMap["getFlipkartSearchResultCount"] = Processor.process_getFlipkartSearchResultCount
5995 
    self._processMap["getAllFkItems"] = Processor.process_getAllFkItems
10140 vikram.rag 5996 
    self._processMap["getFlipkartItemBySkyAtFlipkart"] = Processor.process_getFlipkartItemBySkyAtFlipkart
5944 mandeep.dh 5997 
 
5998 
  def process(self, iprot, oprot):
5999 
    (name, type, seqid) = iprot.readMessageBegin()
6000 
    if name not in self._processMap:
6001 
      iprot.skip(TType.STRUCT)
6002 
      iprot.readMessageEnd()
6003 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6004 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6005 
      x.write(oprot)
6006 
      oprot.writeMessageEnd()
6007 
      oprot.trans.flush()
6008 
      return
6009 
    else:
6010 
      self._processMap[name](self, seqid, iprot, oprot)
6011 
    return True
6012 
 
6013 
  def process_addItem(self, seqid, iprot, oprot):
6014 
    args = addItem_args()
6015 
    args.read(iprot)
6016 
    iprot.readMessageEnd()
6017 
    result = addItem_result()
6018 
    try:
6019 
      result.success = self._handler.addItem(args.item)
6020 
    except CatalogServiceException, cex:
6021 
      result.cex = cex
6022 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
6023 
    result.write(oprot)
6024 
    oprot.writeMessageEnd()
6025 
    oprot.trans.flush()
6026 
 
6027 
  def process_updateItem(self, seqid, iprot, oprot):
6028 
    args = updateItem_args()
6029 
    args.read(iprot)
6030 
    iprot.readMessageEnd()
6031 
    result = updateItem_result()
6032 
    try:
6033 
      result.success = self._handler.updateItem(args.item)
6034 
    except CatalogServiceException, cex:
6035 
      result.cex = cex
6036 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
6037 
    result.write(oprot)
6038 
    oprot.writeMessageEnd()
6039 
    oprot.trans.flush()
6040 
 
6041 
  def process_isActive(self, seqid, iprot, oprot):
6042 
    args = isActive_args()
6043 
    args.read(iprot)
6044 
    iprot.readMessageEnd()
6045 
    result = isActive_result()
6046 
    try:
6047 
      result.success = self._handler.isActive(args.itemId)
6048 
    except CatalogServiceException, isex:
6049 
      result.isex = isex
6050 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
6051 
    result.write(oprot)
6052 
    oprot.writeMessageEnd()
6053 
    oprot.trans.flush()
6054 
 
7438 amit.gupta 6055 
  def process_getItemsStatus(self, seqid, iprot, oprot):
6056 
    args = getItemsStatus_args()
6057 
    args.read(iprot)
6058 
    iprot.readMessageEnd()
6059 
    result = getItemsStatus_result()
6060 
    try:
6061 
      result.success = self._handler.getItemsStatus(args.itemIds)
6062 
    except CatalogServiceException, isex:
6063 
      result.isex = isex
6064 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
6065 
    result.write(oprot)
6066 
    oprot.writeMessageEnd()
6067 
    oprot.trans.flush()
6068 
 
5944 mandeep.dh 6069 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
6070 
    args = getItemStatusDescription_args()
6071 
    args.read(iprot)
6072 
    iprot.readMessageEnd()
6073 
    result = getItemStatusDescription_result()
6074 
    try:
6075 
      result.success = self._handler.getItemStatusDescription(args.itemId)
6076 
    except CatalogServiceException, isex:
6077 
      result.isex = isex
6078 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
6079 
    result.write(oprot)
6080 
    oprot.writeMessageEnd()
6081 
    oprot.trans.flush()
6082 
 
6083 
  def process_startItemOn(self, seqid, iprot, oprot):
6084 
    args = startItemOn_args()
6085 
    args.read(iprot)
6086 
    iprot.readMessageEnd()
6087 
    result = startItemOn_result()
6088 
    try:
6089 
      self._handler.startItemOn(args.item_id, args.timestamp)
6090 
    except CatalogServiceException, cex:
6091 
      result.cex = cex
6092 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
6093 
    result.write(oprot)
6094 
    oprot.writeMessageEnd()
6095 
    oprot.trans.flush()
6096 
 
6097 
  def process_retireItemOn(self, seqid, iprot, oprot):
6098 
    args = retireItemOn_args()
6099 
    args.read(iprot)
6100 
    iprot.readMessageEnd()
6101 
    result = retireItemOn_result()
6102 
    try:
6103 
      self._handler.retireItemOn(args.item_id, args.timestamp)
6104 
    except CatalogServiceException, cex:
6105 
      result.cex = cex
6106 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
6107 
    result.write(oprot)
6108 
    oprot.writeMessageEnd()
6109 
    oprot.trans.flush()
6110 
 
6111 
  def process_changeItemStatus(self, seqid, iprot, oprot):
6112 
    args = changeItemStatus_args()
6113 
    args.read(iprot)
6114 
    iprot.readMessageEnd()
6115 
    result = changeItemStatus_result()
6116 
    try:
6117 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
6118 
    except CatalogServiceException, cex:
6119 
      result.cex = cex
6120 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
6121 
    result.write(oprot)
6122 
    oprot.writeMessageEnd()
6123 
    oprot.trans.flush()
6124 
 
6125 
  def process_getItem(self, seqid, iprot, oprot):
6126 
    args = getItem_args()
6127 
    args.read(iprot)
6128 
    iprot.readMessageEnd()
6129 
    result = getItem_result()
6130 
    try:
6131 
      result.success = self._handler.getItem(args.item_id)
6132 
    except CatalogServiceException, cex:
6133 
      result.cex = cex
6134 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
6135 
    result.write(oprot)
6136 
    oprot.writeMessageEnd()
6137 
    oprot.trans.flush()
6138 
 
6139 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
6140 
    args = getItemsByCatalogId_args()
6141 
    args.read(iprot)
6142 
    iprot.readMessageEnd()
6143 
    result = getItemsByCatalogId_result()
6144 
    try:
6145 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
6146 
    except CatalogServiceException, cex:
6147 
      result.cex = cex
6148 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
6149 
    result.write(oprot)
6150 
    oprot.writeMessageEnd()
6151 
    oprot.trans.flush()
6152 
 
6153 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
6154 
    args = getValidItemsByCatalogId_args()
6155 
    args.read(iprot)
6156 
    iprot.readMessageEnd()
6157 
    result = getValidItemsByCatalogId_result()
6158 
    try:
6159 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
6160 
    except CatalogServiceException, cex:
6161 
      result.cex = cex
6162 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
6163 
    result.write(oprot)
6164 
    oprot.writeMessageEnd()
6165 
    oprot.trans.flush()
6166 
 
6167 
  def process_getAllItems(self, seqid, iprot, oprot):
6168 
    args = getAllItems_args()
6169 
    args.read(iprot)
6170 
    iprot.readMessageEnd()
6171 
    result = getAllItems_result()
6172 
    try:
6173 
      result.success = self._handler.getAllItems(args.isActive)
6174 
    except CatalogServiceException, cex:
6175 
      result.cex = cex
6176 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
6177 
    result.write(oprot)
6178 
    oprot.writeMessageEnd()
6179 
    oprot.trans.flush()
6180 
 
6181 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
6182 
    args = getAllItemsByStatus_args()
6183 
    args.read(iprot)
6184 
    iprot.readMessageEnd()
6185 
    result = getAllItemsByStatus_result()
6186 
    try:
6187 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
6188 
    except CatalogServiceException, cex:
6189 
      result.cex = cex
6190 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
6191 
    result.write(oprot)
6192 
    oprot.writeMessageEnd()
6193 
    oprot.trans.flush()
6194 
 
6195 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
6196 
    args = markItemAsContentComplete_args()
6197 
    args.read(iprot)
6198 
    iprot.readMessageEnd()
6199 
    result = markItemAsContentComplete_result()
6200 
    try:
9253 rajveer 6201 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 6202 
    except CatalogServiceException, cex:
6203 
      result.cex = cex
6204 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
6205 
    result.write(oprot)
6206 
    oprot.writeMessageEnd()
6207 
    oprot.trans.flush()
6208 
 
6209 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
6210 
    args = getAllItemsInRange_args()
6211 
    args.read(iprot)
6212 
    iprot.readMessageEnd()
6213 
    result = getAllItemsInRange_result()
6214 
    try:
6215 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
6216 
    except CatalogServiceException, cex:
6217 
      result.cex = cex
6218 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
6219 
    result.write(oprot)
6220 
    oprot.writeMessageEnd()
6221 
    oprot.trans.flush()
6222 
 
6223 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
6224 
    args = getAllItemsByStatusInRange_args()
6225 
    args.read(iprot)
6226 
    iprot.readMessageEnd()
6227 
    result = getAllItemsByStatusInRange_result()
6228 
    try:
6229 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
6230 
    except CatalogServiceException, cex:
6231 
      result.cex = cex
6232 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
6233 
    result.write(oprot)
6234 
    oprot.writeMessageEnd()
6235 
    oprot.trans.flush()
6236 
 
6237 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
6238 
    args = getItemCountByStatus_args()
6239 
    args.read(iprot)
6240 
    iprot.readMessageEnd()
6241 
    result = getItemCountByStatus_result()
6242 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
6243 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
6244 
    result.write(oprot)
6245 
    oprot.writeMessageEnd()
6246 
    oprot.trans.flush()
6247 
 
6248 
  def process_getBestSellers(self, seqid, iprot, oprot):
6249 
    args = getBestSellers_args()
6250 
    args.read(iprot)
6251 
    iprot.readMessageEnd()
6252 
    result = getBestSellers_result()
6253 
    try:
6254 
      result.success = self._handler.getBestSellers()
6255 
    except CatalogServiceException, isex:
6256 
      result.isex = isex
6257 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
6258 
    result.write(oprot)
6259 
    oprot.writeMessageEnd()
6260 
    oprot.trans.flush()
6261 
 
6262 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
6263 
    args = getBestSellersCatalogIds_args()
6264 
    args.read(iprot)
6265 
    iprot.readMessageEnd()
6266 
    result = getBestSellersCatalogIds_result()
6267 
    try:
6268 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6269 
    except CatalogServiceException, cex:
6270 
      result.cex = cex
6271 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
6272 
    result.write(oprot)
6273 
    oprot.writeMessageEnd()
6274 
    oprot.trans.flush()
6275 
 
6276 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
6277 
    args = getBestSellersCount_args()
6278 
    args.read(iprot)
6279 
    iprot.readMessageEnd()
6280 
    result = getBestSellersCount_result()
6281 
    try:
6282 
      result.success = self._handler.getBestSellersCount()
6283 
    except CatalogServiceException, cex:
6284 
      result.cex = cex
6285 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
6286 
    result.write(oprot)
6287 
    oprot.writeMessageEnd()
6288 
    oprot.trans.flush()
6289 
 
6290 
  def process_getBestDeals(self, seqid, iprot, oprot):
6291 
    args = getBestDeals_args()
6292 
    args.read(iprot)
6293 
    iprot.readMessageEnd()
6294 
    result = getBestDeals_result()
6295 
    try:
6296 
      result.success = self._handler.getBestDeals()
6297 
    except CatalogServiceException, isex:
6298 
      result.isex = isex
6299 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
6300 
    result.write(oprot)
6301 
    oprot.writeMessageEnd()
6302 
    oprot.trans.flush()
6303 
 
6304 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
6305 
    args = getBestDealsCatalogIds_args()
6306 
    args.read(iprot)
6307 
    iprot.readMessageEnd()
6308 
    result = getBestDealsCatalogIds_result()
6309 
    try:
6310 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6311 
    except CatalogServiceException, cex:
6312 
      result.cex = cex
6313 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
6314 
    result.write(oprot)
6315 
    oprot.writeMessageEnd()
6316 
    oprot.trans.flush()
6317 
 
6318 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
6319 
    args = getBestDealsCount_args()
6320 
    args.read(iprot)
6321 
    iprot.readMessageEnd()
6322 
    result = getBestDealsCount_result()
6323 
    try:
6324 
      result.success = self._handler.getBestDealsCount()
6325 
    except CatalogServiceException, cex:
6326 
      result.cex = cex
6327 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
6328 
    result.write(oprot)
6329 
    oprot.writeMessageEnd()
6330 
    oprot.trans.flush()
6331 
 
6332 
  def process_getComingSoon(self, seqid, iprot, oprot):
6333 
    args = getComingSoon_args()
6334 
    args.read(iprot)
6335 
    iprot.readMessageEnd()
6336 
    result = getComingSoon_result()
6337 
    try:
6338 
      result.success = self._handler.getComingSoon()
6339 
    except CatalogServiceException, isex:
6340 
      result.isex = isex
6341 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
6342 
    result.write(oprot)
6343 
    oprot.writeMessageEnd()
6344 
    oprot.trans.flush()
6345 
 
6346 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
6347 
    args = getComingSoonCatalogIds_args()
6348 
    args.read(iprot)
6349 
    iprot.readMessageEnd()
6350 
    result = getComingSoonCatalogIds_result()
6351 
    try:
6352 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6353 
    except CatalogServiceException, cex:
6354 
      result.cex = cex
6355 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
6356 
    result.write(oprot)
6357 
    oprot.writeMessageEnd()
6358 
    oprot.trans.flush()
6359 
 
6360 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
6361 
    args = getComingSoonCount_args()
6362 
    args.read(iprot)
6363 
    iprot.readMessageEnd()
6364 
    result = getComingSoonCount_result()
6365 
    try:
6366 
      result.success = self._handler.getComingSoonCount()
6367 
    except CatalogServiceException, cex:
6368 
      result.cex = cex
6369 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
6370 
    result.write(oprot)
6371 
    oprot.writeMessageEnd()
6372 
    oprot.trans.flush()
6373 
 
6374 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
6375 
    args = getLatestArrivals_args()
6376 
    args.read(iprot)
6377 
    iprot.readMessageEnd()
6378 
    result = getLatestArrivals_result()
6379 
    try:
6380 
      result.success = self._handler.getLatestArrivals()
6381 
    except CatalogServiceException, isex:
6382 
      result.isex = isex
6383 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
6384 
    result.write(oprot)
6385 
    oprot.writeMessageEnd()
6386 
    oprot.trans.flush()
6387 
 
6388 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
6389 
    args = getLatestArrivalsCatalogIds_args()
6390 
    args.read(iprot)
6391 
    iprot.readMessageEnd()
6392 
    result = getLatestArrivalsCatalogIds_result()
6393 
    try:
6394 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
6395 
    except CatalogServiceException, cex:
6396 
      result.cex = cex
6397 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
6398 
    result.write(oprot)
6399 
    oprot.writeMessageEnd()
6400 
    oprot.trans.flush()
6401 
 
6402 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
6403 
    args = getLatestArrivalsCount_args()
6404 
    args.read(iprot)
6405 
    iprot.readMessageEnd()
6406 
    result = getLatestArrivalsCount_result()
6407 
    try:
6408 
      result.success = self._handler.getLatestArrivalsCount()
6409 
    except CatalogServiceException, cex:
6410 
      result.cex = cex
6411 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
6412 
    result.write(oprot)
6413 
    oprot.writeMessageEnd()
6414 
    oprot.trans.flush()
6415 
 
6416 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
6417 
    args = generateNewEntityID_args()
6418 
    args.read(iprot)
6419 
    iprot.readMessageEnd()
6420 
    result = generateNewEntityID_result()
6421 
    result.success = self._handler.generateNewEntityID()
6422 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
6423 
    result.write(oprot)
6424 
    oprot.writeMessageEnd()
6425 
    oprot.trans.flush()
6426 
 
6427 
  def process_addCategory(self, seqid, iprot, oprot):
6428 
    args = addCategory_args()
6429 
    args.read(iprot)
6430 
    iprot.readMessageEnd()
6431 
    result = addCategory_result()
6432 
    result.success = self._handler.addCategory(args.category)
6433 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
6434 
    result.write(oprot)
6435 
    oprot.writeMessageEnd()
6436 
    oprot.trans.flush()
6437 
 
6438 
  def process_getCategory(self, seqid, iprot, oprot):
6439 
    args = getCategory_args()
6440 
    args.read(iprot)
6441 
    iprot.readMessageEnd()
6442 
    result = getCategory_result()
6443 
    result.success = self._handler.getCategory(args.id)
6444 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
6445 
    result.write(oprot)
6446 
    oprot.writeMessageEnd()
6447 
    oprot.trans.flush()
6448 
 
6449 
  def process_getAllCategories(self, seqid, iprot, oprot):
6450 
    args = getAllCategories_args()
6451 
    args.read(iprot)
6452 
    iprot.readMessageEnd()
6453 
    result = getAllCategories_result()
6454 
    result.success = self._handler.getAllCategories()
6455 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
6456 
    result.write(oprot)
6457 
    oprot.writeMessageEnd()
6458 
    oprot.trans.flush()
6459 
 
6460 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
6461 
    args = getAllSimilarItems_args()
6462 
    args.read(iprot)
6463 
    iprot.readMessageEnd()
6464 
    result = getAllSimilarItems_result()
6465 
    result.success = self._handler.getAllSimilarItems(args.itemId)
6466 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
6467 
    result.write(oprot)
6468 
    oprot.writeMessageEnd()
6469 
    oprot.trans.flush()
6470 
 
6471 
  def process_addSimilarItem(self, seqid, iprot, oprot):
6472 
    args = addSimilarItem_args()
6473 
    args.read(iprot)
6474 
    iprot.readMessageEnd()
6475 
    result = addSimilarItem_result()
6476 
    try:
6477 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
6478 
    except CatalogServiceException, cex:
6479 
      result.cex = cex
6480 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
6481 
    result.write(oprot)
6482 
    oprot.writeMessageEnd()
6483 
    oprot.trans.flush()
6484 
 
6512 kshitij.so 6485 
  def process_addTag(self, seqid, iprot, oprot):
6486 
    args = addTag_args()
6487 
    args.read(iprot)
6488 
    iprot.readMessageEnd()
6489 
    result = addTag_result()
6490 
    result.success = self._handler.addTag(args.displayName, args.itemId)
6491 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
6492 
    result.write(oprot)
6493 
    oprot.writeMessageEnd()
6494 
    oprot.trans.flush()
6495 
 
6496 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
6497 
    args = deleteEntityTag_args()
6498 
    args.read(iprot)
6499 
    iprot.readMessageEnd()
6500 
    result = deleteEntityTag_result()
6501 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
6502 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
6503 
    result.write(oprot)
6504 
    oprot.writeMessageEnd()
6505 
    oprot.trans.flush()
6506 
 
6507 
  def process_deleteTag(self, seqid, iprot, oprot):
6508 
    args = deleteTag_args()
6509 
    args.read(iprot)
6510 
    iprot.readMessageEnd()
6511 
    result = deleteTag_result()
6512 
    result.success = self._handler.deleteTag(args.displayName)
6513 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
6514 
    result.write(oprot)
6515 
    oprot.writeMessageEnd()
6516 
    oprot.trans.flush()
6517 
 
6518 
  def process_getAllTags(self, seqid, iprot, oprot):
6519 
    args = getAllTags_args()
6520 
    args.read(iprot)
6521 
    iprot.readMessageEnd()
6522 
    result = getAllTags_result()
6523 
    result.success = self._handler.getAllTags()
6524 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
6525 
    result.write(oprot)
6526 
    oprot.writeMessageEnd()
6527 
    oprot.trans.flush()
6528 
 
6529 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
6530 
    args = getAllEntitiesByTagName_args()
6531 
    args.read(iprot)
6532 
    iprot.readMessageEnd()
6533 
    result = getAllEntitiesByTagName_result()
6534 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
6535 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
6536 
    result.write(oprot)
6537 
    oprot.writeMessageEnd()
6538 
    oprot.trans.flush()
6539 
 
6845 amit.gupta 6540 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
6541 
    args = getAllEntityTags_args()
6542 
    args.read(iprot)
6543 
    iprot.readMessageEnd()
6544 
    result = getAllEntityTags_result()
6545 
    result.success = self._handler.getAllEntityTags()
6546 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
6547 
    result.write(oprot)
6548 
    oprot.writeMessageEnd()
6549 
    oprot.trans.flush()
6550 
 
6850 kshitij.so 6551 
  def process_addBanner(self, seqid, iprot, oprot):
6552 
    args = addBanner_args()
6553 
    args.read(iprot)
6554 
    iprot.readMessageEnd()
6555 
    result = addBanner_result()
10097 kshitij.so 6556 
    result.success = self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 6557 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
6558 
    result.write(oprot)
6559 
    oprot.writeMessageEnd()
6560 
    oprot.trans.flush()
6561 
 
8579 kshitij.so 6562 
  def process_updateBanner(self, seqid, iprot, oprot):
6563 
    args = updateBanner_args()
6564 
    args.read(iprot)
6565 
    iprot.readMessageEnd()
6566 
    result = updateBanner_result()
6567 
    result.success = self._handler.updateBanner(args.banner)
6568 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
6569 
    result.write(oprot)
6570 
    oprot.writeMessageEnd()
6571 
    oprot.trans.flush()
6572 
 
6850 kshitij.so 6573 
  def process_getAllBanners(self, seqid, iprot, oprot):
6574 
    args = getAllBanners_args()
6575 
    args.read(iprot)
6576 
    iprot.readMessageEnd()
6577 
    result = getAllBanners_result()
6578 
    result.success = self._handler.getAllBanners()
6579 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
6580 
    result.write(oprot)
6581 
    oprot.writeMessageEnd()
6582 
    oprot.trans.flush()
6583 
 
6584 
  def process_deleteBanner(self, seqid, iprot, oprot):
6585 
    args = deleteBanner_args()
6586 
    args.read(iprot)
6587 
    iprot.readMessageEnd()
6588 
    result = deleteBanner_result()
9155 kshitij.so 6589 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 6590 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
6591 
    result.write(oprot)
6592 
    oprot.writeMessageEnd()
6593 
    oprot.trans.flush()
6594 
 
6595 
  def process_getBannerDetails(self, seqid, iprot, oprot):
6596 
    args = getBannerDetails_args()
6597 
    args.read(iprot)
6598 
    iprot.readMessageEnd()
6599 
    result = getBannerDetails_result()
9155 kshitij.so 6600 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 6601 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
6602 
    result.write(oprot)
6603 
    oprot.writeMessageEnd()
6604 
    oprot.trans.flush()
6605 
 
6606 
  def process_getActiveBanners(self, seqid, iprot, oprot):
6607 
    args = getActiveBanners_args()
6608 
    args.read(iprot)
6609 
    iprot.readMessageEnd()
6610 
    result = getActiveBanners_result()
6611 
    result.success = self._handler.getActiveBanners()
6612 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
6613 
    result.write(oprot)
6614 
    oprot.writeMessageEnd()
6615 
    oprot.trans.flush()
6616 
 
6849 kshitij.so 6617 
  def process_addBannerMap(self, seqid, iprot, oprot):
6618 
    args = addBannerMap_args()
6619 
    args.read(iprot)
6620 
    iprot.readMessageEnd()
6621 
    result = addBannerMap_result()
8579 kshitij.so 6622 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 6623 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
6624 
    result.write(oprot)
6625 
    oprot.writeMessageEnd()
6626 
    oprot.trans.flush()
6627 
 
8579 kshitij.so 6628 
  def process_updateBannerMap(self, seqid, iprot, oprot):
6629 
    args = updateBannerMap_args()
6630 
    args.read(iprot)
6631 
    iprot.readMessageEnd()
6632 
    result = updateBannerMap_result()
6633 
    result.success = self._handler.updateBannerMap(args.bannerMap)
6634 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
6635 
    result.write(oprot)
6636 
    oprot.writeMessageEnd()
6637 
    oprot.trans.flush()
6638 
 
6849 kshitij.so 6639 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
6640 
    args = deleteBannerMap_args()
6641 
    args.read(iprot)
6642 
    iprot.readMessageEnd()
6643 
    result = deleteBannerMap_result()
6644 
    result.success = self._handler.deleteBannerMap(args.bannerName)
6645 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
6646 
    result.write(oprot)
6647 
    oprot.writeMessageEnd()
6648 
    oprot.trans.flush()
6649 
 
6650 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
6651 
    args = getBannerMapDetails_args()
6652 
    args.read(iprot)
6653 
    iprot.readMessageEnd()
6654 
    result = getBannerMapDetails_result()
9155 kshitij.so 6655 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 6656 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
6657 
    result.write(oprot)
6658 
    oprot.writeMessageEnd()
6659 
    oprot.trans.flush()
6660 
 
8579 kshitij.so 6661 
  def process_addBannerUri(self, seqid, iprot, oprot):
6662 
    args = addBannerUri_args()
6663 
    args.read(iprot)
6664 
    iprot.readMessageEnd()
6665 
    result = addBannerUri_result()
6666 
    self._handler.addBannerUri(args.bannerUriMappings)
6667 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
6668 
    result.write(oprot)
6669 
    oprot.writeMessageEnd()
6670 
    oprot.trans.flush()
6671 
 
6672 
  def process_getUriMapping(self, seqid, iprot, oprot):
6673 
    args = getUriMapping_args()
6674 
    args.read(iprot)
6675 
    iprot.readMessageEnd()
6676 
    result = getUriMapping_result()
9155 kshitij.so 6677 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 6678 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
6679 
    result.write(oprot)
6680 
    oprot.writeMessageEnd()
6681 
    oprot.trans.flush()
6682 
 
6683 
  def process_addCampaign(self, seqid, iprot, oprot):
6684 
    args = addCampaign_args()
6685 
    args.read(iprot)
6686 
    iprot.readMessageEnd()
6687 
    result = addCampaign_result()
6688 
    self._handler.addCampaign(args.campaign)
6689 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
6690 
    result.write(oprot)
6691 
    oprot.writeMessageEnd()
6692 
    oprot.trans.flush()
6693 
 
6694 
  def process_getCampaigns(self, seqid, iprot, oprot):
6695 
    args = getCampaigns_args()
6696 
    args.read(iprot)
6697 
    iprot.readMessageEnd()
6698 
    result = getCampaigns_result()
6699 
    result.success = self._handler.getCampaigns(args.campaignName)
6700 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
6701 
    result.write(oprot)
6702 
    oprot.writeMessageEnd()
6703 
    oprot.trans.flush()
6704 
 
6705 
  def process_deleteCampaign(self, seqid, iprot, oprot):
6706 
    args = deleteCampaign_args()
6707 
    args.read(iprot)
6708 
    iprot.readMessageEnd()
6709 
    result = deleteCampaign_result()
6710 
    self._handler.deleteCampaign(args.campaignId)
6711 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
6712 
    result.write(oprot)
6713 
    oprot.writeMessageEnd()
6714 
    oprot.trans.flush()
6715 
 
6716 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
6717 
    args = getAllCampaigns_args()
6718 
    args.read(iprot)
6719 
    iprot.readMessageEnd()
6720 
    result = getAllCampaigns_result()
6721 
    result.success = self._handler.getAllCampaigns()
6722 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
6723 
    result.write(oprot)
6724 
    oprot.writeMessageEnd()
6725 
    oprot.trans.flush()
6726 
 
9155 kshitij.so 6727 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
6728 
    args = getActiveBannersForMobileSite_args()
6729 
    args.read(iprot)
6730 
    iprot.readMessageEnd()
6731 
    result = getActiveBannersForMobileSite_result()
6732 
    result.success = self._handler.getActiveBannersForMobileSite()
6733 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
6734 
    result.write(oprot)
6735 
    oprot.writeMessageEnd()
6736 
    oprot.trans.flush()
6737 
 
5944 mandeep.dh 6738 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
6739 
    args = deleteSimilarItem_args()
6740 
    args.read(iprot)
6741 
    iprot.readMessageEnd()
6742 
    result = deleteSimilarItem_result()
6743 
    try:
6744 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
6745 
    except CatalogServiceException, cex:
6746 
      result.cex = cex
6747 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
6748 
    result.write(oprot)
6749 
    oprot.writeMessageEnd()
6750 
    oprot.trans.flush()
6751 
 
6752 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
6753 
    args = checkSimilarItem_args()
6754 
    args.read(iprot)
6755 
    iprot.readMessageEnd()
6756 
    result = checkSimilarItem_result()
6757 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
6758 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
6759 
    result.write(oprot)
6760 
    oprot.writeMessageEnd()
6761 
    oprot.trans.flush()
6762 
 
6763 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
6764 
    args = validateRiskyStatus_args()
6765 
    args.read(iprot)
6766 
    iprot.readMessageEnd()
6767 
    result = validateRiskyStatus_result()
6768 
    self._handler.validateRiskyStatus(args.itemId)
6769 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
6770 
    result.write(oprot)
6771 
    oprot.writeMessageEnd()
6772 
    oprot.trans.flush()
6773 
 
6774 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
6775 
    args = changeItemRiskyFlag_args()
6776 
    args.read(iprot)
6777 
    iprot.readMessageEnd()
6778 
    result = changeItemRiskyFlag_result()
6779 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
6780 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
6781 
    result.write(oprot)
6782 
    oprot.writeMessageEnd()
6783 
    oprot.trans.flush()
6784 
 
6785 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
6786 
    args = getItemsByRiskyFlag_args()
6787 
    args.read(iprot)
6788 
    iprot.readMessageEnd()
6789 
    result = getItemsByRiskyFlag_result()
6790 
    result.success = self._handler.getItemsByRiskyFlag()
6791 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
6792 
    result.write(oprot)
6793 
    oprot.writeMessageEnd()
6794 
    oprot.trans.flush()
6795 
 
6796 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
6797 
    args = getItemsForMasterSheet_args()
6798 
    args.read(iprot)
6799 
    iprot.readMessageEnd()
6800 
    result = getItemsForMasterSheet_result()
6801 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
6802 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
6803 
    result.write(oprot)
6804 
    oprot.writeMessageEnd()
6805 
    oprot.trans.flush()
6806 
 
6807 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
6808 
    args = getSimilarItemsCatalogIds_args()
6809 
    args.read(iprot)
6810 
    iprot.readMessageEnd()
6811 
    result = getSimilarItemsCatalogIds_result()
6812 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
6813 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
6814 
    result.write(oprot)
6815 
    oprot.writeMessageEnd()
6816 
    oprot.trans.flush()
6817 
 
6818 
  def process_addProductNotification(self, seqid, iprot, oprot):
6819 
    args = addProductNotification_args()
6820 
    args.read(iprot)
6821 
    iprot.readMessageEnd()
6822 
    result = addProductNotification_result()
6823 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
6824 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
6825 
    result.write(oprot)
6826 
    oprot.writeMessageEnd()
6827 
    oprot.trans.flush()
6828 
 
6829 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
6830 
    args = sendProductNotifications_args()
6831 
    args.read(iprot)
6832 
    iprot.readMessageEnd()
6833 
    result = sendProductNotifications_result()
6834 
    result.success = self._handler.sendProductNotifications()
6835 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
6836 
    result.write(oprot)
6837 
    oprot.writeMessageEnd()
6838 
    oprot.trans.flush()
6839 
 
6840 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
6841 
    args = getAllBrandsByCategory_args()
6842 
    args.read(iprot)
6843 
    iprot.readMessageEnd()
6844 
    result = getAllBrandsByCategory_result()
6845 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
6846 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
6847 
    result.write(oprot)
6848 
    oprot.writeMessageEnd()
6849 
    oprot.trans.flush()
6850 
 
6851 
  def process_getAllBrands(self, seqid, iprot, oprot):
6852 
    args = getAllBrands_args()
6853 
    args.read(iprot)
6854 
    iprot.readMessageEnd()
6855 
    result = getAllBrands_result()
6856 
    result.success = self._handler.getAllBrands()
6857 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
6858 
    result.write(oprot)
6859 
    oprot.writeMessageEnd()
6860 
    oprot.trans.flush()
6861 
 
6862 
  def process_getAllSources(self, seqid, iprot, oprot):
6863 
    args = getAllSources_args()
6864 
    args.read(iprot)
6865 
    iprot.readMessageEnd()
6866 
    result = getAllSources_result()
6867 
    result.success = self._handler.getAllSources()
6868 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
6869 
    result.write(oprot)
6870 
    oprot.writeMessageEnd()
6871 
    oprot.trans.flush()
6872 
 
6873 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
6874 
    args = getItemPricingBySource_args()
6875 
    args.read(iprot)
6876 
    iprot.readMessageEnd()
6877 
    result = getItemPricingBySource_result()
6878 
    try:
6879 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
6880 
    except CatalogServiceException, cex:
6881 
      result.cex = cex
6882 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
6883 
    result.write(oprot)
6884 
    oprot.writeMessageEnd()
6885 
    oprot.trans.flush()
6886 
 
6887 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
6888 
    args = addSourceItemPricing_args()
6889 
    args.read(iprot)
6890 
    iprot.readMessageEnd()
6891 
    result = addSourceItemPricing_result()
6892 
    try:
6893 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
6894 
    except CatalogServiceException, cex:
6895 
      result.cex = cex
6896 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
6897 
    result.write(oprot)
6898 
    oprot.writeMessageEnd()
6899 
    oprot.trans.flush()
6900 
 
6901 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
6902 
    args = getAllSourcePricing_args()
6903 
    args.read(iprot)
6904 
    iprot.readMessageEnd()
6905 
    result = getAllSourcePricing_result()
6906 
    try:
6907 
      result.success = self._handler.getAllSourcePricing(args.itemId)
6908 
    except CatalogServiceException, cex:
6909 
      result.cex = cex
6910 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
6911 
    result.write(oprot)
6912 
    oprot.writeMessageEnd()
6913 
    oprot.trans.flush()
6914 
 
6915 
  def process_getItemForSource(self, seqid, iprot, oprot):
6916 
    args = getItemForSource_args()
6917 
    args.read(iprot)
6918 
    iprot.readMessageEnd()
6919 
    result = getItemForSource_result()
6920 
    try:
6921 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
6922 
    except CatalogServiceException, cex:
6923 
      result.cex = cex
6924 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
6925 
    result.write(oprot)
6926 
    oprot.writeMessageEnd()
6927 
    oprot.trans.flush()
6928 
 
6929 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
6930 
    args = searchItemsInRange_args()
6931 
    args.read(iprot)
6932 
    iprot.readMessageEnd()
6933 
    result = searchItemsInRange_result()
6934 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
6935 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
6936 
    result.write(oprot)
6937 
    oprot.writeMessageEnd()
6938 
    oprot.trans.flush()
6939 
 
6940 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
6941 
    args = getSearchResultCount_args()
6942 
    args.read(iprot)
6943 
    iprot.readMessageEnd()
6944 
    result = getSearchResultCount_result()
6945 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
6946 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
6947 
    result.write(oprot)
6948 
    oprot.writeMessageEnd()
6949 
    oprot.trans.flush()
6950 
 
6951 
  def process_getProductNotifications(self, seqid, iprot, oprot):
6952 
    args = getProductNotifications_args()
6953 
    args.read(iprot)
6954 
    iprot.readMessageEnd()
6955 
    result = getProductNotifications_result()
6956 
    result.success = self._handler.getProductNotifications(args.startDateTime)
6957 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
6958 
    result.write(oprot)
6959 
    oprot.writeMessageEnd()
6960 
    oprot.trans.flush()
6961 
 
6962 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
6963 
    args = getProductNotificationRequestCount_args()
6964 
    args.read(iprot)
6965 
    iprot.readMessageEnd()
6966 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 6967 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 6968 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
6969 
    result.write(oprot)
6970 
    oprot.writeMessageEnd()
6971 
    oprot.trans.flush()
6972 
 
6973 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
6974 
    args = addAuthorizationLog_args()
6975 
    args.read(iprot)
6976 
    iprot.readMessageEnd()
6977 
    result = addAuthorizationLog_result()
6978 
    try:
6979 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
6980 
    except CatalogServiceException, cex:
6981 
      result.cex = cex
6982 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
6983 
    result.write(oprot)
6984 
    oprot.writeMessageEnd()
6985 
    oprot.trans.flush()
6986 
 
6987 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
6988 
    args = addupdateVoucherForItem_args()
6989 
    args.read(iprot)
6990 
    iprot.readMessageEnd()
6991 
    result = addupdateVoucherForItem_result()
6992 
    try:
6993 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
6994 
    except CatalogServiceException, cex:
6995 
      result.cex = cex
6996 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
6997 
    result.write(oprot)
6998 
    oprot.writeMessageEnd()
6999 
    oprot.trans.flush()
7000 
 
7001 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
7002 
    args = deleteVoucherForItem_args()
7003 
    args.read(iprot)
7004 
    iprot.readMessageEnd()
7005 
    result = deleteVoucherForItem_result()
7006 
    try:
7007 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
7008 
    except CatalogServiceException, cex:
7009 
      result.cex = cex
7010 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
7011 
    result.write(oprot)
7012 
    oprot.writeMessageEnd()
7013 
    oprot.trans.flush()
7014 
 
7015 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
7016 
    args = getVoucherAmount_args()
7017 
    args.read(iprot)
7018 
    iprot.readMessageEnd()
7019 
    result = getVoucherAmount_result()
7020 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
7021 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
7022 
    result.write(oprot)
7023 
    oprot.writeMessageEnd()
7024 
    oprot.trans.flush()
7025 
 
7026 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
7027 
    args = getAllItemVouchers_args()
7028 
    args.read(iprot)
7029 
    iprot.readMessageEnd()
7030 
    result = getAllItemVouchers_result()
7031 
    result.success = self._handler.getAllItemVouchers(args.itemId)
7032 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
7033 
    result.write(oprot)
7034 
    oprot.writeMessageEnd()
7035 
    oprot.trans.flush()
7036 
 
7037 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
7038 
    args = isValidCatalogItemId_args()
7039 
    args.read(iprot)
7040 
    iprot.readMessageEnd()
7041 
    result = isValidCatalogItemId_result()
7042 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
7043 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
7044 
    result.write(oprot)
7045 
    oprot.writeMessageEnd()
7046 
    oprot.trans.flush()
7047 
 
6039 amit.gupta 7048 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
7049 
    args = getVatPercentageForItem_args()
7050 
    args.read(iprot)
7051 
    iprot.readMessageEnd()
7052 
    result = getVatPercentageForItem_result()
7340 amit.gupta 7053 
    try:
7054 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
7055 
    except CatalogServiceException, cex:
7056 
      result.cex = cex
6039 amit.gupta 7057 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
7058 
    result.write(oprot)
7059 
    oprot.writeMessageEnd()
7060 
    oprot.trans.flush()
5944 mandeep.dh 7061 
 
6039 amit.gupta 7062 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
7063 
    args = getVatAmountForItem_args()
7064 
    args.read(iprot)
7065 
    iprot.readMessageEnd()
7066 
    result = getVatAmountForItem_result()
7067 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
7068 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
7069 
    result.write(oprot)
7070 
    oprot.writeMessageEnd()
7071 
    oprot.trans.flush()
7072 
 
6531 vikram.rag 7073 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
7074 
    args = getAllIgnoredInventoryUpdateItemsList_args()
7075 
    args.read(iprot)
7076 
    iprot.readMessageEnd()
7077 
    result = getAllIgnoredInventoryUpdateItemsList_result()
7078 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
7079 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
7080 
    result.write(oprot)
7081 
    oprot.writeMessageEnd()
7082 
    oprot.trans.flush()
6039 amit.gupta 7083 
 
6821 amar.kumar 7084 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
7085 
    args = getAllAliveItems_args()
7086 
    args.read(iprot)
7087 
    iprot.readMessageEnd()
7088 
    result = getAllAliveItems_result()
7089 
    result.success = self._handler.getAllAliveItems()
7090 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
7091 
    result.write(oprot)
7092 
    oprot.writeMessageEnd()
7093 
    oprot.trans.flush()
7094 
 
6805 anupam.sin 7095 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
7096 
    args = getInsuranceAmount_args()
7097 
    args.read(iprot)
7098 
    iprot.readMessageEnd()
7099 
    result = getInsuranceAmount_result()
6921 anupam.sin 7100 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 7101 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
7102 
    result.write(oprot)
7103 
    oprot.writeMessageEnd()
7104 
    oprot.trans.flush()
6531 vikram.rag 7105 
 
6805 anupam.sin 7106 
  def process_getInsurer(self, seqid, iprot, oprot):
7107 
    args = getInsurer_args()
7108 
    args.read(iprot)
7109 
    iprot.readMessageEnd()
7110 
    result = getInsurer_result()
7111 
    result.success = self._handler.getInsurer(args.insurerId)
7112 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
7113 
    result.write(oprot)
7114 
    oprot.writeMessageEnd()
7115 
    oprot.trans.flush()
7116 
 
6838 vikram.rag 7117 
  def process_getAllInsurers(self, seqid, iprot, oprot):
7118 
    args = getAllInsurers_args()
7119 
    args.read(iprot)
7120 
    iprot.readMessageEnd()
7121 
    result = getAllInsurers_result()
7122 
    result.success = self._handler.getAllInsurers()
7123 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
7124 
    result.write(oprot)
7125 
    oprot.writeMessageEnd()
7126 
    oprot.trans.flush()
6805 anupam.sin 7127 
 
6962 rajveer 7128 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
7129 
    args = updateInsuranceDeclaredAmount_args()
7130 
    args.read(iprot)
7131 
    iprot.readMessageEnd()
7132 
    result = updateInsuranceDeclaredAmount_result()
7133 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
7134 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
7135 
    result.write(oprot)
7136 
    oprot.writeMessageEnd()
7137 
    oprot.trans.flush()
6838 vikram.rag 7138 
 
7190 amar.kumar 7139 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
7140 
    args = getFreebieForItem_args()
7141 
    args.read(iprot)
7142 
    iprot.readMessageEnd()
7143 
    result = getFreebieForItem_result()
7144 
    result.success = self._handler.getFreebieForItem(args.itemId)
7145 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
7146 
    result.write(oprot)
7147 
    oprot.writeMessageEnd()
7148 
    oprot.trans.flush()
6962 rajveer 7149 
 
7190 amar.kumar 7150 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
7151 
    args = addOrUpdateFreebieForItem_args()
7152 
    args.read(iprot)
7153 
    iprot.readMessageEnd()
7154 
    result = addOrUpdateFreebieForItem_result()
7155 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
7156 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
7157 
    result.write(oprot)
7158 
    oprot.writeMessageEnd()
7159 
    oprot.trans.flush()
7160 
 
7272 amit.gupta 7161 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
7162 
    args = addOrUpdateBrandInfo_args()
7163 
    args.read(iprot)
7164 
    iprot.readMessageEnd()
7165 
    result = addOrUpdateBrandInfo_result()
7166 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
7167 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
7168 
    result.write(oprot)
7169 
    oprot.writeMessageEnd()
7170 
    oprot.trans.flush()
7171 
 
7172 
  def process_getBrandInfo(self, seqid, iprot, oprot):
7173 
    args = getBrandInfo_args()
7174 
    args.read(iprot)
7175 
    iprot.readMessageEnd()
7176 
    result = getBrandInfo_result()
7177 
    result.success = self._handler.getBrandInfo()
7178 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
7179 
    result.write(oprot)
7180 
    oprot.writeMessageEnd()
7181 
    oprot.trans.flush()
7182 
 
7256 rajveer 7183 
  def process_getStorePricing(self, seqid, iprot, oprot):
7184 
    args = getStorePricing_args()
7185 
    args.read(iprot)
7186 
    iprot.readMessageEnd()
7187 
    result = getStorePricing_result()
7188 
    result.success = self._handler.getStorePricing(args.itemId)
7189 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
7190 
    result.write(oprot)
7191 
    oprot.writeMessageEnd()
7192 
    oprot.trans.flush()
7190 amar.kumar 7193 
 
7306 rajveer 7194 
  def process_getStorePricings(self, seqid, iprot, oprot):
7195 
    args = getStorePricings_args()
7196 
    args.read(iprot)
7197 
    iprot.readMessageEnd()
7198 
    result = getStorePricings_result()
7199 
    result.success = self._handler.getStorePricings(args.itemIds)
7200 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
7201 
    result.write(oprot)
7202 
    oprot.writeMessageEnd()
7203 
    oprot.trans.flush()
7204 
 
7265 rajveer 7205 
  def process_updateStorePricing(self, seqid, iprot, oprot):
7206 
    args = updateStorePricing_args()
7207 
    args.read(iprot)
7208 
    iprot.readMessageEnd()
7209 
    result = updateStorePricing_result()
7382 rajveer 7210 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 7211 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
7212 
    result.write(oprot)
7213 
    oprot.writeMessageEnd()
7214 
    oprot.trans.flush()
7256 rajveer 7215 
 
7281 kshitij.so 7216 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
7217 
    args = getAllAmazonListedItems_args()
7218 
    args.read(iprot)
7219 
    iprot.readMessageEnd()
7220 
    result = getAllAmazonListedItems_result()
7221 
    result.success = self._handler.getAllAmazonListedItems()
7222 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
7223 
    result.write(oprot)
7224 
    oprot.writeMessageEnd()
7225 
    oprot.trans.flush()
7265 rajveer 7226 
 
8619 kshitij.so 7227 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
7228 
    args = searchAmazonItems_args()
7229 
    args.read(iprot)
7230 
    iprot.readMessageEnd()
7231 
    result = searchAmazonItems_result()
7232 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
7233 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
7234 
    result.write(oprot)
7235 
    oprot.writeMessageEnd()
7236 
    oprot.trans.flush()
7237 
 
7238 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
7239 
    args = getAmazonSearchResultCount_args()
7240 
    args.read(iprot)
7241 
    iprot.readMessageEnd()
7242 
    result = getAmazonSearchResultCount_result()
7243 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
7244 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
7245 
    result.write(oprot)
7246 
    oprot.writeMessageEnd()
7247 
    oprot.trans.flush()
7248 
 
7249 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
7250 
    args = getCountForAmazonlistedItems_args()
7251 
    args.read(iprot)
7252 
    iprot.readMessageEnd()
7253 
    result = getCountForAmazonlistedItems_result()
7254 
    result.success = self._handler.getCountForAmazonlistedItems()
7255 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
7256 
    result.write(oprot)
7257 
    oprot.writeMessageEnd()
7258 
    oprot.trans.flush()
7259 
 
7281 kshitij.so 7260 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
7261 
    args = getAmazonItemDetails_args()
7262 
    args.read(iprot)
7263 
    iprot.readMessageEnd()
7264 
    result = getAmazonItemDetails_result()
7265 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
7266 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
7267 
    result.write(oprot)
7268 
    oprot.writeMessageEnd()
7269 
    oprot.trans.flush()
7270 
 
7271 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
7272 
    args = updateAmazonItemDetails_args()
7273 
    args.read(iprot)
7274 
    iprot.readMessageEnd()
7275 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 7276 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 7277 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
7278 
    result.write(oprot)
7279 
    oprot.writeMessageEnd()
7280 
    oprot.trans.flush()
7281 
 
7282 
  def process_addAmazonItem(self, seqid, iprot, oprot):
7283 
    args = addAmazonItem_args()
7284 
    args.read(iprot)
7285 
    iprot.readMessageEnd()
7286 
    result = addAmazonItem_result()
7287 
    self._handler.addAmazonItem(args.amazonlisted)
7288 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
7289 
    result.write(oprot)
7290 
    oprot.writeMessageEnd()
7291 
    oprot.trans.flush()
7292 
 
7291 vikram.rag 7293 
  def process_getAsinItems(self, seqid, iprot, oprot):
7294 
    args = getAsinItems_args()
7295 
    args.read(iprot)
7296 
    iprot.readMessageEnd()
7297 
    result = getAsinItems_result()
7298 
    result.success = self._handler.getAsinItems()
7299 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
7300 
    result.write(oprot)
7301 
    oprot.writeMessageEnd()
7302 
    oprot.trans.flush()
7281 kshitij.so 7303 
 
7291 vikram.rag 7304 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
7305 
    args = getAllFbaListedItems_args()
7306 
    args.read(iprot)
7307 
    iprot.readMessageEnd()
7308 
    result = getAllFbaListedItems_result()
7309 
    result.success = self._handler.getAllFbaListedItems()
7310 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
7311 
    result.write(oprot)
7312 
    oprot.writeMessageEnd()
7313 
    oprot.trans.flush()
7314 
 
7315 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
7316 
    args = getAllNonFbaListedItems_args()
7317 
    args.read(iprot)
7318 
    iprot.readMessageEnd()
7319 
    result = getAllNonFbaListedItems_result()
7320 
    result.success = self._handler.getAllNonFbaListedItems()
7321 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
7322 
    result.write(oprot)
7323 
    oprot.writeMessageEnd()
7324 
    oprot.trans.flush()
7325 
 
7460 kshitij.so 7326 
  def process_updateItemInventory(self, seqid, iprot, oprot):
7327 
    args = updateItemInventory_args()
7328 
    args.read(iprot)
7329 
    iprot.readMessageEnd()
7330 
    result = updateItemInventory_result()
7331 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
7332 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
7333 
    result.write(oprot)
7334 
    oprot.writeMessageEnd()
7335 
    oprot.trans.flush()
7291 vikram.rag 7336 
 
7770 kshitij.so 7337 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
7338 
    args = updateTimestampForAmazonFeeds_args()
7339 
    args.read(iprot)
7340 
    iprot.readMessageEnd()
7341 
    result = updateTimestampForAmazonFeeds_result()
7342 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
7343 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
7344 
    result.write(oprot)
7345 
    oprot.writeMessageEnd()
7346 
    oprot.trans.flush()
7460 kshitij.so 7347 
 
7897 amar.kumar 7348 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
7349 
    args = getAllParentCategories_args()
7350 
    args.read(iprot)
7351 
    iprot.readMessageEnd()
7352 
    result = getAllParentCategories_result()
7353 
    result.success = self._handler.getAllParentCategories()
7354 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
7355 
    result.write(oprot)
7356 
    oprot.writeMessageEnd()
7357 
    oprot.trans.flush()
7770 kshitij.so 7358 
 
7977 kshitij.so 7359 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
7360 
    args = addPageViewEvent_args()
7361 
    args.read(iprot)
7362 
    iprot.readMessageEnd()
7363 
    result = addPageViewEvent_result()
7364 
    self._handler.addPageViewEvent(args.pageViewEvents)
7365 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
7366 
    result.write(oprot)
7367 
    oprot.writeMessageEnd()
7368 
    oprot.trans.flush()
7897 amar.kumar 7369 
 
7977 kshitij.so 7370 
  def process_addCartEvent(self, seqid, iprot, oprot):
7371 
    args = addCartEvent_args()
7372 
    args.read(iprot)
7373 
    iprot.readMessageEnd()
7374 
    result = addCartEvent_result()
7375 
    self._handler.addCartEvent(args.cartEvents)
7376 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
7377 
    result.write(oprot)
7378 
    oprot.writeMessageEnd()
7379 
    oprot.trans.flush()
7380 
 
8182 amar.kumar 7381 
  def process_addEbayItem(self, seqid, iprot, oprot):
7382 
    args = addEbayItem_args()
7383 
    args.read(iprot)
7384 
    iprot.readMessageEnd()
7385 
    result = addEbayItem_result()
7386 
    self._handler.addEbayItem(args.ebayItem)
7387 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
7388 
    result.write(oprot)
7389 
    oprot.writeMessageEnd()
7390 
    oprot.trans.flush()
7391 
 
7392 
  def process_getEbayItem(self, seqid, iprot, oprot):
7393 
    args = getEbayItem_args()
7394 
    args.read(iprot)
7395 
    iprot.readMessageEnd()
7396 
    result = getEbayItem_result()
7397 
    result.success = self._handler.getEbayItem(args.listingId)
7398 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
7399 
    result.write(oprot)
7400 
    oprot.writeMessageEnd()
7401 
    oprot.trans.flush()
7402 
 
7403 
  def process_updateEbayItem(self, seqid, iprot, oprot):
7404 
    args = updateEbayItem_args()
7405 
    args.read(iprot)
7406 
    iprot.readMessageEnd()
7407 
    result = updateEbayItem_result()
7408 
    self._handler.updateEbayItem(args.ebayItem)
7409 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
7410 
    result.write(oprot)
7411 
    oprot.writeMessageEnd()
7412 
    oprot.trans.flush()
7413 
 
8139 kshitij.so 7414 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
7415 
    args = getAmazonListedItems_args()
7416 
    args.read(iprot)
7417 
    iprot.readMessageEnd()
7418 
    result = getAmazonListedItems_result()
7419 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
7420 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
7421 
    result.write(oprot)
7422 
    oprot.writeMessageEnd()
7423 
    oprot.trans.flush()
7977 kshitij.so 7424 
 
8168 kshitij.so 7425 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
7426 
    args = updateAmazonAttributesInBulk_args()
7427 
    args.read(iprot)
7428 
    iprot.readMessageEnd()
7429 
    result = updateAmazonAttributesInBulk_result()
7430 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
7431 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
7432 
    result.write(oprot)
7433 
    oprot.writeMessageEnd()
7434 
    oprot.trans.flush()
8139 kshitij.so 7435 
 
8379 vikram.rag 7436 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
7437 
    args = getAllItemstoListOnFba_args()
7438 
    args.read(iprot)
7439 
    iprot.readMessageEnd()
7440 
    result = getAllItemstoListOnFba_result()
7441 
    result.success = self._handler.getAllItemstoListOnFba()
7442 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
7443 
    result.write(oprot)
7444 
    oprot.writeMessageEnd()
7445 
    oprot.trans.flush()
8168 kshitij.so 7446 
 
8379 vikram.rag 7447 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
7448 
    args = getAllItemstoListOnNonFba_args()
7449 
    args.read(iprot)
7450 
    iprot.readMessageEnd()
7451 
    result = getAllItemstoListOnNonFba_result()
7452 
    result.success = self._handler.getAllItemstoListOnNonFba()
7453 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
7454 
    result.write(oprot)
7455 
    oprot.writeMessageEnd()
7456 
    oprot.trans.flush()
7457 
 
8619 kshitij.so 7458 
  def process_updateAsin(self, seqid, iprot, oprot):
7459 
    args = updateAsin_args()
7460 
    args.read(iprot)
7461 
    iprot.readMessageEnd()
7462 
    result = updateAsin_result()
7463 
    self._handler.updateAsin(args.item)
7464 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
7465 
    result.write(oprot)
7466 
    oprot.writeMessageEnd()
7467 
    oprot.trans.flush()
8616 vikram.rag 7468 
 
8739 vikram.rag 7469 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
7470 
    args = addOrUpdateSnapdealItem_args()
7471 
    args.read(iprot)
7472 
    iprot.readMessageEnd()
7473 
    result = addOrUpdateSnapdealItem_result()
7474 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
7475 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
7476 
    result.write(oprot)
7477 
    oprot.writeMessageEnd()
7478 
    oprot.trans.flush()
8619 kshitij.so 7479 
 
8739 vikram.rag 7480 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
7481 
    args = getSnapdealItem_args()
7482 
    args.read(iprot)
7483 
    iprot.readMessageEnd()
7484 
    result = getSnapdealItem_result()
7485 
    result.success = self._handler.getSnapdealItem(args.item_id)
7486 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
7487 
    result.write(oprot)
7488 
    oprot.writeMessageEnd()
7489 
    oprot.trans.flush()
7490 
 
9242 kshitij.so 7491 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
7492 
    args = getSnapdealItemDetails_args()
7493 
    args.read(iprot)
7494 
    iprot.readMessageEnd()
7495 
    result = getSnapdealItemDetails_result()
7496 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
7497 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
7498 
    result.write(oprot)
7499 
    oprot.writeMessageEnd()
7500 
    oprot.trans.flush()
7501 
 
8739 vikram.rag 7502 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
7503 
    args = getAllSnapdealItems_args()
7504 
    args.read(iprot)
7505 
    iprot.readMessageEnd()
7506 
    result = getAllSnapdealItems_result()
7507 
    result.success = self._handler.getAllSnapdealItems()
7508 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
7509 
    result.write(oprot)
7510 
    oprot.writeMessageEnd()
7511 
    oprot.trans.flush()
7512 
 
9242 kshitij.so 7513 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
7514 
    args = getSnapdealItems_args()
7515 
    args.read(iprot)
7516 
    iprot.readMessageEnd()
7517 
    result = getSnapdealItems_result()
7518 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
7519 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
7520 
    result.write(oprot)
7521 
    oprot.writeMessageEnd()
7522 
    oprot.trans.flush()
8739 vikram.rag 7523 
 
9242 kshitij.so 7524 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
7525 
    args = searchSnapdealItems_args()
7526 
    args.read(iprot)
7527 
    iprot.readMessageEnd()
7528 
    result = searchSnapdealItems_result()
7529 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
7530 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
7531 
    result.write(oprot)
7532 
    oprot.writeMessageEnd()
7533 
    oprot.trans.flush()
7534 
 
7535 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
7536 
    args = getCountForSnapdealItems_args()
7537 
    args.read(iprot)
7538 
    iprot.readMessageEnd()
7539 
    result = getCountForSnapdealItems_result()
7540 
    result.success = self._handler.getCountForSnapdealItems()
7541 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
7542 
    result.write(oprot)
7543 
    oprot.writeMessageEnd()
7544 
    oprot.trans.flush()
7545 
 
7546 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
7547 
    args = getSnapdealSearchResultCount_args()
7548 
    args.read(iprot)
7549 
    iprot.readMessageEnd()
7550 
    result = getSnapdealSearchResultCount_result()
7551 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
7552 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
7553 
    result.write(oprot)
7554 
    oprot.writeMessageEnd()
7555 
    oprot.trans.flush()
7556 
 
9299 kshitij.so 7557 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
7558 
    args = getPrefferedInsurerForItem_args()
7559 
    args.read(iprot)
7560 
    iprot.readMessageEnd()
7561 
    result = getPrefferedInsurerForItem_result()
7562 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
7563 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
7564 
    result.write(oprot)
7565 
    oprot.writeMessageEnd()
7566 
    oprot.trans.flush()
9242 kshitij.so 7567 
 
9456 vikram.rag 7568 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
7569 
    args = getSnapdealItembySkuAtSnapdeal_args()
7570 
    args.read(iprot)
7571 
    iprot.readMessageEnd()
7572 
    result = getSnapdealItembySkuAtSnapdeal_result()
7573 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
7574 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
7575 
    result.write(oprot)
7576 
    oprot.writeMessageEnd()
7577 
    oprot.trans.flush()
9299 kshitij.so 7578 
 
9621 manish.sha 7579 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
7580 
    args = getProductFeedSubmit_args()
7581 
    args.read(iprot)
7582 
    iprot.readMessageEnd()
7583 
    result = getProductFeedSubmit_result()
7584 
    try:
7585 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
7586 
    except CatalogServiceException, cex:
7587 
      result.cex = cex
7588 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
7589 
    result.write(oprot)
7590 
    oprot.writeMessageEnd()
7591 
    oprot.trans.flush()
9456 vikram.rag 7592 
 
9621 manish.sha 7593 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
7594 
    args = addProductFeedSubmit_args()
7595 
    args.read(iprot)
7596 
    iprot.readMessageEnd()
7597 
    result = addProductFeedSubmit_result()
7598 
    try:
7599 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
7600 
    except CatalogServiceException, cex:
7601 
      result.cex = cex
7602 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
7603 
    result.write(oprot)
7604 
    oprot.writeMessageEnd()
7605 
    oprot.trans.flush()
7606 
 
7607 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
7608 
    args = updateProductFeedSubmit_args()
7609 
    args.read(iprot)
7610 
    iprot.readMessageEnd()
7611 
    result = updateProductFeedSubmit_result()
7612 
    try:
7613 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
7614 
    except CatalogServiceException, cex:
7615 
      result.cex = cex
7616 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
7617 
    result.write(oprot)
7618 
    oprot.writeMessageEnd()
7619 
    oprot.trans.flush()
7620 
 
7621 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
7622 
    args = deleteProductFeedSubmit_args()
7623 
    args.read(iprot)
7624 
    iprot.readMessageEnd()
7625 
    result = deleteProductFeedSubmit_result()
7626 
    try:
7627 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
7628 
    except CatalogServiceException, cex:
7629 
      result.cex = cex
7630 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
7631 
    result.write(oprot)
7632 
    oprot.writeMessageEnd()
7633 
    oprot.trans.flush()
7634 
 
7635 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
7636 
    args = getAllProductFeedSubmit_args()
7637 
    args.read(iprot)
7638 
    iprot.readMessageEnd()
7639 
    result = getAllProductFeedSubmit_result()
7640 
    try:
7641 
      result.success = self._handler.getAllProductFeedSubmit()
7642 
    except CatalogServiceException, cex:
7643 
      result.cex = cex
7644 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
7645 
    result.write(oprot)
7646 
    oprot.writeMessageEnd()
7647 
    oprot.trans.flush()
7648 
 
9724 kshitij.so 7649 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
7650 
    args = getMarketplacedetailsForItem_args()
7651 
    args.read(iprot)
7652 
    iprot.readMessageEnd()
7653 
    result = getMarketplacedetailsForItem_result()
7654 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
7655 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
7656 
    result.write(oprot)
7657 
    oprot.writeMessageEnd()
7658 
    oprot.trans.flush()
9621 manish.sha 7659 
 
9724 kshitij.so 7660 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
7661 
    args = updateMarketplaceAttributesForItem_args()
7662 
    args.read(iprot)
7663 
    iprot.readMessageEnd()
7664 
    result = updateMarketplaceAttributesForItem_result()
7665 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
7666 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
7667 
    result.write(oprot)
7668 
    oprot.writeMessageEnd()
7669 
    oprot.trans.flush()
7670 
 
9779 kshitij.so 7671 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
7672 
    args = getCostingForMarketplace_args()
7673 
    args.read(iprot)
7674 
    iprot.readMessageEnd()
7675 
    result = getCostingForMarketplace_result()
7676 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
7677 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
7678 
    result.write(oprot)
7679 
    oprot.writeMessageEnd()
7680 
    oprot.trans.flush()
7681 
 
9776 vikram.rag 7682 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
7683 
    args = getMarketPlaceItemsForPriceUpdate_args()
7684 
    args.read(iprot)
7685 
    iprot.readMessageEnd()
7686 
    result = getMarketPlaceItemsForPriceUpdate_result()
7687 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
7688 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
7689 
    result.write(oprot)
7690 
    oprot.writeMessageEnd()
7691 
    oprot.trans.flush()
9724 kshitij.so 7692 
 
9776 vikram.rag 7693 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
7694 
    args = updateMarketPlacePriceUpdateStatus_args()
7695 
    args.read(iprot)
7696 
    iprot.readMessageEnd()
7697 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 7698 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 7699 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
7700 
    result.write(oprot)
7701 
    oprot.writeMessageEnd()
7702 
    oprot.trans.flush()
7703 
 
9861 rajveer 7704 
  def process_updateItemHoldInventory(self, seqid, iprot, oprot):
7705 
    args = updateItemHoldInventory_args()
7706 
    args.read(iprot)
7707 
    iprot.readMessageEnd()
7708 
    result = updateItemHoldInventory_result()
7709 
    self._handler.updateItemHoldInventory(args.itemHoldMap)
7710 
    oprot.writeMessageBegin("updateItemHoldInventory", TMessageType.REPLY, seqid)
7711 
    result.write(oprot)
7712 
    oprot.writeMessageEnd()
7713 
    oprot.trans.flush()
9776 vikram.rag 7714 
 
9895 vikram.rag 7715 
  def process_updateNlcAtMarketplaces(self, seqid, iprot, oprot):
7716 
    args = updateNlcAtMarketplaces_args()
7717 
    args.read(iprot)
7718 
    iprot.readMessageEnd()
7719 
    result = updateNlcAtMarketplaces_result()
7720 
    self._handler.updateNlcAtMarketplaces(args.item_id, args.vendor_id, args.nlc)
7721 
    oprot.writeMessageBegin("updateNlcAtMarketplaces", TMessageType.REPLY, seqid)
7722 
    result.write(oprot)
7723 
    oprot.writeMessageEnd()
7724 
    oprot.trans.flush()
9861 rajveer 7725 
 
9945 vikram.rag 7726 
  def process_getAllFlipkartItems(self, seqid, iprot, oprot):
7727 
    args = getAllFlipkartItems_args()
7728 
    args.read(iprot)
7729 
    iprot.readMessageEnd()
7730 
    result = getAllFlipkartItems_result()
7731 
    result.success = self._handler.getAllFlipkartItems()
7732 
    oprot.writeMessageBegin("getAllFlipkartItems", TMessageType.REPLY, seqid)
7733 
    result.write(oprot)
7734 
    oprot.writeMessageEnd()
7735 
    oprot.trans.flush()
9895 vikram.rag 7736 
 
10097 kshitij.so 7737 
  def process_addOrUpdateFlipkartItem(self, seqid, iprot, oprot):
7738 
    args = addOrUpdateFlipkartItem_args()
7739 
    args.read(iprot)
7740 
    iprot.readMessageEnd()
7741 
    result = addOrUpdateFlipkartItem_result()
7742 
    result.success = self._handler.addOrUpdateFlipkartItem(args.flipkartitem)
7743 
    oprot.writeMessageBegin("addOrUpdateFlipkartItem", TMessageType.REPLY, seqid)
7744 
    result.write(oprot)
7745 
    oprot.writeMessageEnd()
7746 
    oprot.trans.flush()
9945 vikram.rag 7747 
 
10097 kshitij.so 7748 
  def process_getFlipkartItem(self, seqid, iprot, oprot):
7749 
    args = getFlipkartItem_args()
7750 
    args.read(iprot)
7751 
    iprot.readMessageEnd()
7752 
    result = getFlipkartItem_result()
7753 
    result.success = self._handler.getFlipkartItem(args.item_id)
7754 
    oprot.writeMessageBegin("getFlipkartItem", TMessageType.REPLY, seqid)
7755 
    result.write(oprot)
7756 
    oprot.writeMessageEnd()
7757 
    oprot.trans.flush()
7758 
 
7759 
  def process_getFlipkartItemDetails(self, seqid, iprot, oprot):
7760 
    args = getFlipkartItemDetails_args()
7761 
    args.read(iprot)
7762 
    iprot.readMessageEnd()
7763 
    result = getFlipkartItemDetails_result()
7764 
    result.success = self._handler.getFlipkartItemDetails(args.item_id)
7765 
    oprot.writeMessageBegin("getFlipkartItemDetails", TMessageType.REPLY, seqid)
7766 
    result.write(oprot)
7767 
    oprot.writeMessageEnd()
7768 
    oprot.trans.flush()
7769 
 
7770 
  def process_getFlipkartItems(self, seqid, iprot, oprot):
7771 
    args = getFlipkartItems_args()
7772 
    args.read(iprot)
7773 
    iprot.readMessageEnd()
7774 
    result = getFlipkartItems_result()
7775 
    result.success = self._handler.getFlipkartItems(args.offset, args.limit)
7776 
    oprot.writeMessageBegin("getFlipkartItems", TMessageType.REPLY, seqid)
7777 
    result.write(oprot)
7778 
    oprot.writeMessageEnd()
7779 
    oprot.trans.flush()
7780 
 
7781 
  def process_searchFlipkartItems(self, seqid, iprot, oprot):
7782 
    args = searchFlipkartItems_args()
7783 
    args.read(iprot)
7784 
    iprot.readMessageEnd()
7785 
    result = searchFlipkartItems_result()
7786 
    result.success = self._handler.searchFlipkartItems(args.searchTerm, args.offset, args.limit)
7787 
    oprot.writeMessageBegin("searchFlipkartItems", TMessageType.REPLY, seqid)
7788 
    result.write(oprot)
7789 
    oprot.writeMessageEnd()
7790 
    oprot.trans.flush()
7791 
 
7792 
  def process_getCountForFlipkartItems(self, seqid, iprot, oprot):
7793 
    args = getCountForFlipkartItems_args()
7794 
    args.read(iprot)
7795 
    iprot.readMessageEnd()
7796 
    result = getCountForFlipkartItems_result()
7797 
    result.success = self._handler.getCountForFlipkartItems()
7798 
    oprot.writeMessageBegin("getCountForFlipkartItems", TMessageType.REPLY, seqid)
7799 
    result.write(oprot)
7800 
    oprot.writeMessageEnd()
7801 
    oprot.trans.flush()
7802 
 
7803 
  def process_getFlipkartSearchResultCount(self, seqid, iprot, oprot):
7804 
    args = getFlipkartSearchResultCount_args()
7805 
    args.read(iprot)
7806 
    iprot.readMessageEnd()
7807 
    result = getFlipkartSearchResultCount_result()
7808 
    result.success = self._handler.getFlipkartSearchResultCount(args.searchTerm)
7809 
    oprot.writeMessageBegin("getFlipkartSearchResultCount", TMessageType.REPLY, seqid)
7810 
    result.write(oprot)
7811 
    oprot.writeMessageEnd()
7812 
    oprot.trans.flush()
7813 
 
7814 
  def process_getAllFkItems(self, seqid, iprot, oprot):
7815 
    args = getAllFkItems_args()
7816 
    args.read(iprot)
7817 
    iprot.readMessageEnd()
7818 
    result = getAllFkItems_result()
7819 
    result.success = self._handler.getAllFkItems()
7820 
    oprot.writeMessageBegin("getAllFkItems", TMessageType.REPLY, seqid)
7821 
    result.write(oprot)
7822 
    oprot.writeMessageEnd()
7823 
    oprot.trans.flush()
7824 
 
10140 vikram.rag 7825 
  def process_getFlipkartItemBySkyAtFlipkart(self, seqid, iprot, oprot):
7826 
    args = getFlipkartItemBySkyAtFlipkart_args()
7827 
    args.read(iprot)
7828 
    iprot.readMessageEnd()
7829 
    result = getFlipkartItemBySkyAtFlipkart_result()
7830 
    result.success = self._handler.getFlipkartItemBySkyAtFlipkart(args.sku)
7831 
    oprot.writeMessageBegin("getFlipkartItemBySkyAtFlipkart", TMessageType.REPLY, seqid)
7832 
    result.write(oprot)
7833 
    oprot.writeMessageEnd()
7834 
    oprot.trans.flush()
10097 kshitij.so 7835 
 
10140 vikram.rag 7836 
 
5944 mandeep.dh 7837 
# HELPER FUNCTIONS AND STRUCTURES
7838 
 
7839 
class addItem_args:
7840 
  """
7841 
  Attributes:
7842 
   - item
7843 
  """
7844 
 
7845 
  thrift_spec = (
7846 
    None, # 0
7847 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7848 
  )
7849 
 
7850 
  def __init__(self, item=None,):
7851 
    self.item = item
7852 
 
7853 
  def read(self, iprot):
7854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7856 
      return
7857 
    iprot.readStructBegin()
7858 
    while True:
7859 
      (fname, ftype, fid) = iprot.readFieldBegin()
7860 
      if ftype == TType.STOP:
7861 
        break
7862 
      if fid == 1:
7863 
        if ftype == TType.STRUCT:
7864 
          self.item = Item()
7865 
          self.item.read(iprot)
7866 
        else:
7867 
          iprot.skip(ftype)
7868 
      else:
7869 
        iprot.skip(ftype)
7870 
      iprot.readFieldEnd()
7871 
    iprot.readStructEnd()
7872 
 
7873 
  def write(self, oprot):
7874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7876 
      return
7877 
    oprot.writeStructBegin('addItem_args')
7878 
    if self.item is not None:
7879 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7880 
      self.item.write(oprot)
7881 
      oprot.writeFieldEnd()
7882 
    oprot.writeFieldStop()
7883 
    oprot.writeStructEnd()
7884 
 
7885 
  def validate(self):
7886 
    return
7887 
 
7888 
 
7889 
  def __repr__(self):
7890 
    L = ['%s=%r' % (key, value)
7891 
      for key, value in self.__dict__.iteritems()]
7892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7893 
 
7894 
  def __eq__(self, other):
7895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7896 
 
7897 
  def __ne__(self, other):
7898 
    return not (self == other)
7899 
 
7900 
class addItem_result:
7901 
  """
7902 
  Attributes:
7903 
   - success
7904 
   - cex
7905 
  """
7906 
 
7907 
  thrift_spec = (
7908 
    (0, TType.I64, 'success', None, None, ), # 0
7909 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7910 
  )
7911 
 
7912 
  def __init__(self, success=None, cex=None,):
7913 
    self.success = success
7914 
    self.cex = cex
7915 
 
7916 
  def read(self, iprot):
7917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7919 
      return
7920 
    iprot.readStructBegin()
7921 
    while True:
7922 
      (fname, ftype, fid) = iprot.readFieldBegin()
7923 
      if ftype == TType.STOP:
7924 
        break
7925 
      if fid == 0:
7926 
        if ftype == TType.I64:
7927 
          self.success = iprot.readI64();
7928 
        else:
7929 
          iprot.skip(ftype)
7930 
      elif fid == 1:
7931 
        if ftype == TType.STRUCT:
7932 
          self.cex = CatalogServiceException()
7933 
          self.cex.read(iprot)
7934 
        else:
7935 
          iprot.skip(ftype)
7936 
      else:
7937 
        iprot.skip(ftype)
7938 
      iprot.readFieldEnd()
7939 
    iprot.readStructEnd()
7940 
 
7941 
  def write(self, oprot):
7942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7944 
      return
7945 
    oprot.writeStructBegin('addItem_result')
7946 
    if self.success is not None:
7947 
      oprot.writeFieldBegin('success', TType.I64, 0)
7948 
      oprot.writeI64(self.success)
7949 
      oprot.writeFieldEnd()
7950 
    if self.cex is not None:
7951 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7952 
      self.cex.write(oprot)
7953 
      oprot.writeFieldEnd()
7954 
    oprot.writeFieldStop()
7955 
    oprot.writeStructEnd()
7956 
 
7957 
  def validate(self):
7958 
    return
7959 
 
7960 
 
7961 
  def __repr__(self):
7962 
    L = ['%s=%r' % (key, value)
7963 
      for key, value in self.__dict__.iteritems()]
7964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7965 
 
7966 
  def __eq__(self, other):
7967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7968 
 
7969 
  def __ne__(self, other):
7970 
    return not (self == other)
7971 
 
7972 
class updateItem_args:
7973 
  """
7974 
  Attributes:
7975 
   - item
7976 
  """
7977 
 
7978 
  thrift_spec = (
7979 
    None, # 0
7980 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7981 
  )
7982 
 
7983 
  def __init__(self, item=None,):
7984 
    self.item = item
7985 
 
7986 
  def read(self, iprot):
7987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7989 
      return
7990 
    iprot.readStructBegin()
7991 
    while True:
7992 
      (fname, ftype, fid) = iprot.readFieldBegin()
7993 
      if ftype == TType.STOP:
7994 
        break
7995 
      if fid == 1:
7996 
        if ftype == TType.STRUCT:
7997 
          self.item = Item()
7998 
          self.item.read(iprot)
7999 
        else:
8000 
          iprot.skip(ftype)
8001 
      else:
8002 
        iprot.skip(ftype)
8003 
      iprot.readFieldEnd()
8004 
    iprot.readStructEnd()
8005 
 
8006 
  def write(self, oprot):
8007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8009 
      return
8010 
    oprot.writeStructBegin('updateItem_args')
8011 
    if self.item is not None:
8012 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
8013 
      self.item.write(oprot)
8014 
      oprot.writeFieldEnd()
8015 
    oprot.writeFieldStop()
8016 
    oprot.writeStructEnd()
8017 
 
8018 
  def validate(self):
8019 
    return
8020 
 
8021 
 
8022 
  def __repr__(self):
8023 
    L = ['%s=%r' % (key, value)
8024 
      for key, value in self.__dict__.iteritems()]
8025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8026 
 
8027 
  def __eq__(self, other):
8028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8029 
 
8030 
  def __ne__(self, other):
8031 
    return not (self == other)
8032 
 
8033 
class updateItem_result:
8034 
  """
8035 
  Attributes:
8036 
   - success
8037 
   - cex
8038 
  """
8039 
 
8040 
  thrift_spec = (
8041 
    (0, TType.I64, 'success', None, None, ), # 0
8042 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8043 
  )
8044 
 
8045 
  def __init__(self, success=None, cex=None,):
8046 
    self.success = success
8047 
    self.cex = cex
8048 
 
8049 
  def read(self, iprot):
8050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8052 
      return
8053 
    iprot.readStructBegin()
8054 
    while True:
8055 
      (fname, ftype, fid) = iprot.readFieldBegin()
8056 
      if ftype == TType.STOP:
8057 
        break
8058 
      if fid == 0:
8059 
        if ftype == TType.I64:
8060 
          self.success = iprot.readI64();
8061 
        else:
8062 
          iprot.skip(ftype)
8063 
      elif fid == 1:
8064 
        if ftype == TType.STRUCT:
8065 
          self.cex = CatalogServiceException()
8066 
          self.cex.read(iprot)
8067 
        else:
8068 
          iprot.skip(ftype)
8069 
      else:
8070 
        iprot.skip(ftype)
8071 
      iprot.readFieldEnd()
8072 
    iprot.readStructEnd()
8073 
 
8074 
  def write(self, oprot):
8075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8077 
      return
8078 
    oprot.writeStructBegin('updateItem_result')
8079 
    if self.success is not None:
8080 
      oprot.writeFieldBegin('success', TType.I64, 0)
8081 
      oprot.writeI64(self.success)
8082 
      oprot.writeFieldEnd()
8083 
    if self.cex is not None:
8084 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8085 
      self.cex.write(oprot)
8086 
      oprot.writeFieldEnd()
8087 
    oprot.writeFieldStop()
8088 
    oprot.writeStructEnd()
8089 
 
8090 
  def validate(self):
8091 
    return
8092 
 
8093 
 
8094 
  def __repr__(self):
8095 
    L = ['%s=%r' % (key, value)
8096 
      for key, value in self.__dict__.iteritems()]
8097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8098 
 
8099 
  def __eq__(self, other):
8100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8101 
 
8102 
  def __ne__(self, other):
8103 
    return not (self == other)
8104 
 
8105 
class isActive_args:
8106 
  """
8107 
  Attributes:
8108 
   - itemId
8109 
  """
8110 
 
8111 
  thrift_spec = (
8112 
    None, # 0
8113 
    (1, TType.I64, 'itemId', None, None, ), # 1
8114 
  )
8115 
 
8116 
  def __init__(self, itemId=None,):
8117 
    self.itemId = itemId
8118 
 
8119 
  def read(self, iprot):
8120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8122 
      return
8123 
    iprot.readStructBegin()
8124 
    while True:
8125 
      (fname, ftype, fid) = iprot.readFieldBegin()
8126 
      if ftype == TType.STOP:
8127 
        break
8128 
      if fid == 1:
8129 
        if ftype == TType.I64:
8130 
          self.itemId = iprot.readI64();
8131 
        else:
8132 
          iprot.skip(ftype)
8133 
      else:
8134 
        iprot.skip(ftype)
8135 
      iprot.readFieldEnd()
8136 
    iprot.readStructEnd()
8137 
 
8138 
  def write(self, oprot):
8139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8141 
      return
8142 
    oprot.writeStructBegin('isActive_args')
8143 
    if self.itemId is not None:
8144 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8145 
      oprot.writeI64(self.itemId)
8146 
      oprot.writeFieldEnd()
8147 
    oprot.writeFieldStop()
8148 
    oprot.writeStructEnd()
8149 
 
8150 
  def validate(self):
8151 
    return
8152 
 
8153 
 
8154 
  def __repr__(self):
8155 
    L = ['%s=%r' % (key, value)
8156 
      for key, value in self.__dict__.iteritems()]
8157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8158 
 
8159 
  def __eq__(self, other):
8160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8161 
 
8162 
  def __ne__(self, other):
8163 
    return not (self == other)
8164 
 
8165 
class isActive_result:
8166 
  """
8167 
  Attributes:
8168 
   - success
8169 
   - isex
8170 
  """
8171 
 
8172 
  thrift_spec = (
8173 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
8174 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8175 
  )
8176 
 
8177 
  def __init__(self, success=None, isex=None,):
8178 
    self.success = success
8179 
    self.isex = isex
8180 
 
8181 
  def read(self, iprot):
8182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8184 
      return
8185 
    iprot.readStructBegin()
8186 
    while True:
8187 
      (fname, ftype, fid) = iprot.readFieldBegin()
8188 
      if ftype == TType.STOP:
8189 
        break
8190 
      if fid == 0:
8191 
        if ftype == TType.STRUCT:
8192 
          self.success = ItemShippingInfo()
8193 
          self.success.read(iprot)
8194 
        else:
8195 
          iprot.skip(ftype)
8196 
      elif fid == 1:
8197 
        if ftype == TType.STRUCT:
8198 
          self.isex = CatalogServiceException()
8199 
          self.isex.read(iprot)
8200 
        else:
8201 
          iprot.skip(ftype)
8202 
      else:
8203 
        iprot.skip(ftype)
8204 
      iprot.readFieldEnd()
8205 
    iprot.readStructEnd()
8206 
 
8207 
  def write(self, oprot):
8208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8210 
      return
8211 
    oprot.writeStructBegin('isActive_result')
8212 
    if self.success is not None:
8213 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8214 
      self.success.write(oprot)
8215 
      oprot.writeFieldEnd()
8216 
    if self.isex is not None:
8217 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8218 
      self.isex.write(oprot)
8219 
      oprot.writeFieldEnd()
8220 
    oprot.writeFieldStop()
8221 
    oprot.writeStructEnd()
8222 
 
8223 
  def validate(self):
8224 
    return
8225 
 
8226 
 
8227 
  def __repr__(self):
8228 
    L = ['%s=%r' % (key, value)
8229 
      for key, value in self.__dict__.iteritems()]
8230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8231 
 
8232 
  def __eq__(self, other):
8233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8234 
 
8235 
  def __ne__(self, other):
8236 
    return not (self == other)
8237 
 
7438 amit.gupta 8238 
class getItemsStatus_args:
8239 
  """
8240 
  Attributes:
8241 
   - itemIds
8242 
  """
8243 
 
8244 
  thrift_spec = (
8245 
    None, # 0
8246 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
8247 
  )
8248 
 
8249 
  def __init__(self, itemIds=None,):
8250 
    self.itemIds = itemIds
8251 
 
8252 
  def read(self, iprot):
8253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8255 
      return
8256 
    iprot.readStructBegin()
8257 
    while True:
8258 
      (fname, ftype, fid) = iprot.readFieldBegin()
8259 
      if ftype == TType.STOP:
8260 
        break
8261 
      if fid == 1:
8262 
        if ftype == TType.LIST:
8263 
          self.itemIds = []
8590 kshitij.so 8264 
          (_etype33, _size30) = iprot.readListBegin()
8265 
          for _i34 in xrange(_size30):
8266 
            _elem35 = iprot.readI64();
8267 
            self.itemIds.append(_elem35)
7438 amit.gupta 8268 
          iprot.readListEnd()
8269 
        else:
8270 
          iprot.skip(ftype)
8271 
      else:
8272 
        iprot.skip(ftype)
8273 
      iprot.readFieldEnd()
8274 
    iprot.readStructEnd()
8275 
 
8276 
  def write(self, oprot):
8277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8279 
      return
8280 
    oprot.writeStructBegin('getItemsStatus_args')
8281 
    if self.itemIds is not None:
8282 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
8283 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 8284 
      for iter36 in self.itemIds:
8285 
        oprot.writeI64(iter36)
7438 amit.gupta 8286 
      oprot.writeListEnd()
8287 
      oprot.writeFieldEnd()
8288 
    oprot.writeFieldStop()
8289 
    oprot.writeStructEnd()
8290 
 
8291 
  def validate(self):
8292 
    return
8293 
 
8294 
 
8295 
  def __repr__(self):
8296 
    L = ['%s=%r' % (key, value)
8297 
      for key, value in self.__dict__.iteritems()]
8298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8299 
 
8300 
  def __eq__(self, other):
8301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8302 
 
8303 
  def __ne__(self, other):
8304 
    return not (self == other)
8305 
 
8306 
class getItemsStatus_result:
8307 
  """
8308 
  Attributes:
8309 
   - success
8310 
   - isex
8311 
  """
8312 
 
8313 
  thrift_spec = (
8314 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
8315 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8316 
  )
8317 
 
8318 
  def __init__(self, success=None, isex=None,):
8319 
    self.success = success
8320 
    self.isex = isex
8321 
 
8322 
  def read(self, iprot):
8323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8325 
      return
8326 
    iprot.readStructBegin()
8327 
    while True:
8328 
      (fname, ftype, fid) = iprot.readFieldBegin()
8329 
      if ftype == TType.STOP:
8330 
        break
8331 
      if fid == 0:
8332 
        if ftype == TType.MAP:
8333 
          self.success = {}
8590 kshitij.so 8334 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
8335 
          for _i41 in xrange(_size37):
8336 
            _key42 = iprot.readI64();
8337 
            _val43 = iprot.readBool();
8338 
            self.success[_key42] = _val43
7438 amit.gupta 8339 
          iprot.readMapEnd()
8340 
        else:
8341 
          iprot.skip(ftype)
8342 
      elif fid == 1:
8343 
        if ftype == TType.STRUCT:
8344 
          self.isex = CatalogServiceException()
8345 
          self.isex.read(iprot)
8346 
        else:
8347 
          iprot.skip(ftype)
8348 
      else:
8349 
        iprot.skip(ftype)
8350 
      iprot.readFieldEnd()
8351 
    iprot.readStructEnd()
8352 
 
8353 
  def write(self, oprot):
8354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8356 
      return
8357 
    oprot.writeStructBegin('getItemsStatus_result')
8358 
    if self.success is not None:
8359 
      oprot.writeFieldBegin('success', TType.MAP, 0)
8360 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 8361 
      for kiter44,viter45 in self.success.items():
8362 
        oprot.writeI64(kiter44)
8363 
        oprot.writeBool(viter45)
7438 amit.gupta 8364 
      oprot.writeMapEnd()
8365 
      oprot.writeFieldEnd()
8366 
    if self.isex is not None:
8367 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8368 
      self.isex.write(oprot)
8369 
      oprot.writeFieldEnd()
8370 
    oprot.writeFieldStop()
8371 
    oprot.writeStructEnd()
8372 
 
8373 
  def validate(self):
8374 
    return
8375 
 
8376 
 
8377 
  def __repr__(self):
8378 
    L = ['%s=%r' % (key, value)
8379 
      for key, value in self.__dict__.iteritems()]
8380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8381 
 
8382 
  def __eq__(self, other):
8383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8384 
 
8385 
  def __ne__(self, other):
8386 
    return not (self == other)
8387 
 
5944 mandeep.dh 8388 
class getItemStatusDescription_args:
8389 
  """
8390 
  Attributes:
8391 
   - itemId
8392 
  """
8393 
 
8394 
  thrift_spec = (
8395 
    None, # 0
8396 
    (1, TType.I64, 'itemId', None, None, ), # 1
8397 
  )
8398 
 
8399 
  def __init__(self, itemId=None,):
8400 
    self.itemId = itemId
8401 
 
8402 
  def read(self, iprot):
8403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8405 
      return
8406 
    iprot.readStructBegin()
8407 
    while True:
8408 
      (fname, ftype, fid) = iprot.readFieldBegin()
8409 
      if ftype == TType.STOP:
8410 
        break
8411 
      if fid == 1:
8412 
        if ftype == TType.I64:
8413 
          self.itemId = iprot.readI64();
8414 
        else:
8415 
          iprot.skip(ftype)
8416 
      else:
8417 
        iprot.skip(ftype)
8418 
      iprot.readFieldEnd()
8419 
    iprot.readStructEnd()
8420 
 
8421 
  def write(self, oprot):
8422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8424 
      return
8425 
    oprot.writeStructBegin('getItemStatusDescription_args')
8426 
    if self.itemId is not None:
8427 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8428 
      oprot.writeI64(self.itemId)
8429 
      oprot.writeFieldEnd()
8430 
    oprot.writeFieldStop()
8431 
    oprot.writeStructEnd()
8432 
 
8433 
  def validate(self):
8434 
    return
8435 
 
8436 
 
8437 
  def __repr__(self):
8438 
    L = ['%s=%r' % (key, value)
8439 
      for key, value in self.__dict__.iteritems()]
8440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8441 
 
8442 
  def __eq__(self, other):
8443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8444 
 
8445 
  def __ne__(self, other):
8446 
    return not (self == other)
8447 
 
8448 
class getItemStatusDescription_result:
8449 
  """
8450 
  Attributes:
8451 
   - success
8452 
   - isex
8453 
  """
8454 
 
8455 
  thrift_spec = (
8456 
    (0, TType.STRING, 'success', None, None, ), # 0
8457 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8458 
  )
8459 
 
8460 
  def __init__(self, success=None, isex=None,):
8461 
    self.success = success
8462 
    self.isex = isex
8463 
 
8464 
  def read(self, iprot):
8465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8467 
      return
8468 
    iprot.readStructBegin()
8469 
    while True:
8470 
      (fname, ftype, fid) = iprot.readFieldBegin()
8471 
      if ftype == TType.STOP:
8472 
        break
8473 
      if fid == 0:
8474 
        if ftype == TType.STRING:
8475 
          self.success = iprot.readString();
8476 
        else:
8477 
          iprot.skip(ftype)
8478 
      elif fid == 1:
8479 
        if ftype == TType.STRUCT:
8480 
          self.isex = CatalogServiceException()
8481 
          self.isex.read(iprot)
8482 
        else:
8483 
          iprot.skip(ftype)
8484 
      else:
8485 
        iprot.skip(ftype)
8486 
      iprot.readFieldEnd()
8487 
    iprot.readStructEnd()
8488 
 
8489 
  def write(self, oprot):
8490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8492 
      return
8493 
    oprot.writeStructBegin('getItemStatusDescription_result')
8494 
    if self.success is not None:
8495 
      oprot.writeFieldBegin('success', TType.STRING, 0)
8496 
      oprot.writeString(self.success)
8497 
      oprot.writeFieldEnd()
8498 
    if self.isex is not None:
8499 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8500 
      self.isex.write(oprot)
8501 
      oprot.writeFieldEnd()
8502 
    oprot.writeFieldStop()
8503 
    oprot.writeStructEnd()
8504 
 
8505 
  def validate(self):
8506 
    return
8507 
 
8508 
 
8509 
  def __repr__(self):
8510 
    L = ['%s=%r' % (key, value)
8511 
      for key, value in self.__dict__.iteritems()]
8512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8513 
 
8514 
  def __eq__(self, other):
8515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8516 
 
8517 
  def __ne__(self, other):
8518 
    return not (self == other)
8519 
 
8520 
class startItemOn_args:
8521 
  """
8522 
  Attributes:
8523 
   - item_id
8524 
   - timestamp
8525 
  """
8526 
 
8527 
  thrift_spec = (
8528 
    None, # 0
8529 
    (1, TType.I64, 'item_id', None, None, ), # 1
8530 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8531 
  )
8532 
 
8533 
  def __init__(self, item_id=None, timestamp=None,):
8534 
    self.item_id = item_id
8535 
    self.timestamp = timestamp
8536 
 
8537 
  def read(self, iprot):
8538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8540 
      return
8541 
    iprot.readStructBegin()
8542 
    while True:
8543 
      (fname, ftype, fid) = iprot.readFieldBegin()
8544 
      if ftype == TType.STOP:
8545 
        break
8546 
      if fid == 1:
8547 
        if ftype == TType.I64:
8548 
          self.item_id = iprot.readI64();
8549 
        else:
8550 
          iprot.skip(ftype)
8551 
      elif fid == 2:
8552 
        if ftype == TType.I64:
8553 
          self.timestamp = iprot.readI64();
8554 
        else:
8555 
          iprot.skip(ftype)
8556 
      else:
8557 
        iprot.skip(ftype)
8558 
      iprot.readFieldEnd()
8559 
    iprot.readStructEnd()
8560 
 
8561 
  def write(self, oprot):
8562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8564 
      return
8565 
    oprot.writeStructBegin('startItemOn_args')
8566 
    if self.item_id is not None:
8567 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8568 
      oprot.writeI64(self.item_id)
8569 
      oprot.writeFieldEnd()
8570 
    if self.timestamp is not None:
8571 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8572 
      oprot.writeI64(self.timestamp)
8573 
      oprot.writeFieldEnd()
8574 
    oprot.writeFieldStop()
8575 
    oprot.writeStructEnd()
8576 
 
8577 
  def validate(self):
8578 
    return
8579 
 
8580 
 
8581 
  def __repr__(self):
8582 
    L = ['%s=%r' % (key, value)
8583 
      for key, value in self.__dict__.iteritems()]
8584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8585 
 
8586 
  def __eq__(self, other):
8587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8588 
 
8589 
  def __ne__(self, other):
8590 
    return not (self == other)
8591 
 
8592 
class startItemOn_result:
8593 
  """
8594 
  Attributes:
8595 
   - cex
8596 
  """
8597 
 
8598 
  thrift_spec = (
8599 
    None, # 0
8600 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8601 
  )
8602 
 
8603 
  def __init__(self, cex=None,):
8604 
    self.cex = cex
8605 
 
8606 
  def read(self, iprot):
8607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8609 
      return
8610 
    iprot.readStructBegin()
8611 
    while True:
8612 
      (fname, ftype, fid) = iprot.readFieldBegin()
8613 
      if ftype == TType.STOP:
8614 
        break
8615 
      if fid == 1:
8616 
        if ftype == TType.STRUCT:
8617 
          self.cex = CatalogServiceException()
8618 
          self.cex.read(iprot)
8619 
        else:
8620 
          iprot.skip(ftype)
8621 
      else:
8622 
        iprot.skip(ftype)
8623 
      iprot.readFieldEnd()
8624 
    iprot.readStructEnd()
8625 
 
8626 
  def write(self, oprot):
8627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8629 
      return
8630 
    oprot.writeStructBegin('startItemOn_result')
8631 
    if self.cex is not None:
8632 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8633 
      self.cex.write(oprot)
8634 
      oprot.writeFieldEnd()
8635 
    oprot.writeFieldStop()
8636 
    oprot.writeStructEnd()
8637 
 
8638 
  def validate(self):
8639 
    return
8640 
 
8641 
 
8642 
  def __repr__(self):
8643 
    L = ['%s=%r' % (key, value)
8644 
      for key, value in self.__dict__.iteritems()]
8645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8646 
 
8647 
  def __eq__(self, other):
8648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8649 
 
8650 
  def __ne__(self, other):
8651 
    return not (self == other)
8652 
 
8653 
class retireItemOn_args:
8654 
  """
8655 
  Attributes:
8656 
   - item_id
8657 
   - timestamp
8658 
  """
8659 
 
8660 
  thrift_spec = (
8661 
    None, # 0
8662 
    (1, TType.I64, 'item_id', None, None, ), # 1
8663 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8664 
  )
8665 
 
8666 
  def __init__(self, item_id=None, timestamp=None,):
8667 
    self.item_id = item_id
8668 
    self.timestamp = timestamp
8669 
 
8670 
  def read(self, iprot):
8671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8673 
      return
8674 
    iprot.readStructBegin()
8675 
    while True:
8676 
      (fname, ftype, fid) = iprot.readFieldBegin()
8677 
      if ftype == TType.STOP:
8678 
        break
8679 
      if fid == 1:
8680 
        if ftype == TType.I64:
8681 
          self.item_id = iprot.readI64();
8682 
        else:
8683 
          iprot.skip(ftype)
8684 
      elif fid == 2:
8685 
        if ftype == TType.I64:
8686 
          self.timestamp = iprot.readI64();
8687 
        else:
8688 
          iprot.skip(ftype)
8689 
      else:
8690 
        iprot.skip(ftype)
8691 
      iprot.readFieldEnd()
8692 
    iprot.readStructEnd()
8693 
 
8694 
  def write(self, oprot):
8695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8697 
      return
8698 
    oprot.writeStructBegin('retireItemOn_args')
8699 
    if self.item_id is not None:
8700 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8701 
      oprot.writeI64(self.item_id)
8702 
      oprot.writeFieldEnd()
8703 
    if self.timestamp is not None:
8704 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8705 
      oprot.writeI64(self.timestamp)
8706 
      oprot.writeFieldEnd()
8707 
    oprot.writeFieldStop()
8708 
    oprot.writeStructEnd()
8709 
 
8710 
  def validate(self):
8711 
    return
8712 
 
8713 
 
8714 
  def __repr__(self):
8715 
    L = ['%s=%r' % (key, value)
8716 
      for key, value in self.__dict__.iteritems()]
8717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8718 
 
8719 
  def __eq__(self, other):
8720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8721 
 
8722 
  def __ne__(self, other):
8723 
    return not (self == other)
8724 
 
8725 
class retireItemOn_result:
8726 
  """
8727 
  Attributes:
8728 
   - cex
8729 
  """
8730 
 
8731 
  thrift_spec = (
8732 
    None, # 0
8733 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8734 
  )
8735 
 
8736 
  def __init__(self, cex=None,):
8737 
    self.cex = cex
8738 
 
8739 
  def read(self, iprot):
8740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8742 
      return
8743 
    iprot.readStructBegin()
8744 
    while True:
8745 
      (fname, ftype, fid) = iprot.readFieldBegin()
8746 
      if ftype == TType.STOP:
8747 
        break
8748 
      if fid == 1:
8749 
        if ftype == TType.STRUCT:
8750 
          self.cex = CatalogServiceException()
8751 
          self.cex.read(iprot)
8752 
        else:
8753 
          iprot.skip(ftype)
8754 
      else:
8755 
        iprot.skip(ftype)
8756 
      iprot.readFieldEnd()
8757 
    iprot.readStructEnd()
8758 
 
8759 
  def write(self, oprot):
8760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8762 
      return
8763 
    oprot.writeStructBegin('retireItemOn_result')
8764 
    if self.cex is not None:
8765 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8766 
      self.cex.write(oprot)
8767 
      oprot.writeFieldEnd()
8768 
    oprot.writeFieldStop()
8769 
    oprot.writeStructEnd()
8770 
 
8771 
  def validate(self):
8772 
    return
8773 
 
8774 
 
8775 
  def __repr__(self):
8776 
    L = ['%s=%r' % (key, value)
8777 
      for key, value in self.__dict__.iteritems()]
8778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8779 
 
8780 
  def __eq__(self, other):
8781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8782 
 
8783 
  def __ne__(self, other):
8784 
    return not (self == other)
8785 
 
8786 
class changeItemStatus_args:
8787 
  """
8788 
  Attributes:
8789 
   - item_id
8790 
   - timestamp
8791 
   - newstatus
8792 
  """
8793 
 
8794 
  thrift_spec = (
8795 
    None, # 0
8796 
    (1, TType.I64, 'item_id', None, None, ), # 1
8797 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8798 
    (3, TType.I32, 'newstatus', None, None, ), # 3
8799 
  )
8800 
 
8801 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
8802 
    self.item_id = item_id
8803 
    self.timestamp = timestamp
8804 
    self.newstatus = newstatus
8805 
 
8806 
  def read(self, iprot):
8807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8809 
      return
8810 
    iprot.readStructBegin()
8811 
    while True:
8812 
      (fname, ftype, fid) = iprot.readFieldBegin()
8813 
      if ftype == TType.STOP:
8814 
        break
8815 
      if fid == 1:
8816 
        if ftype == TType.I64:
8817 
          self.item_id = iprot.readI64();
8818 
        else:
8819 
          iprot.skip(ftype)
8820 
      elif fid == 2:
8821 
        if ftype == TType.I64:
8822 
          self.timestamp = iprot.readI64();
8823 
        else:
8824 
          iprot.skip(ftype)
8825 
      elif fid == 3:
8826 
        if ftype == TType.I32:
8827 
          self.newstatus = iprot.readI32();
8828 
        else:
8829 
          iprot.skip(ftype)
8830 
      else:
8831 
        iprot.skip(ftype)
8832 
      iprot.readFieldEnd()
8833 
    iprot.readStructEnd()
8834 
 
8835 
  def write(self, oprot):
8836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8838 
      return
8839 
    oprot.writeStructBegin('changeItemStatus_args')
8840 
    if self.item_id is not None:
8841 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8842 
      oprot.writeI64(self.item_id)
8843 
      oprot.writeFieldEnd()
8844 
    if self.timestamp is not None:
8845 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8846 
      oprot.writeI64(self.timestamp)
8847 
      oprot.writeFieldEnd()
8848 
    if self.newstatus is not None:
8849 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
8850 
      oprot.writeI32(self.newstatus)
8851 
      oprot.writeFieldEnd()
8852 
    oprot.writeFieldStop()
8853 
    oprot.writeStructEnd()
8854 
 
8855 
  def validate(self):
8856 
    return
8857 
 
8858 
 
8859 
  def __repr__(self):
8860 
    L = ['%s=%r' % (key, value)
8861 
      for key, value in self.__dict__.iteritems()]
8862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8863 
 
8864 
  def __eq__(self, other):
8865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8866 
 
8867 
  def __ne__(self, other):
8868 
    return not (self == other)
8869 
 
8870 
class changeItemStatus_result:
8871 
  """
8872 
  Attributes:
8873 
   - cex
8874 
  """
8875 
 
8876 
  thrift_spec = (
8877 
    None, # 0
8878 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8879 
  )
8880 
 
8881 
  def __init__(self, cex=None,):
8882 
    self.cex = cex
8883 
 
8884 
  def read(self, iprot):
8885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8887 
      return
8888 
    iprot.readStructBegin()
8889 
    while True:
8890 
      (fname, ftype, fid) = iprot.readFieldBegin()
8891 
      if ftype == TType.STOP:
8892 
        break
8893 
      if fid == 1:
8894 
        if ftype == TType.STRUCT:
8895 
          self.cex = CatalogServiceException()
8896 
          self.cex.read(iprot)
8897 
        else:
8898 
          iprot.skip(ftype)
8899 
      else:
8900 
        iprot.skip(ftype)
8901 
      iprot.readFieldEnd()
8902 
    iprot.readStructEnd()
8903 
 
8904 
  def write(self, oprot):
8905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8907 
      return
8908 
    oprot.writeStructBegin('changeItemStatus_result')
8909 
    if self.cex is not None:
8910 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8911 
      self.cex.write(oprot)
8912 
      oprot.writeFieldEnd()
8913 
    oprot.writeFieldStop()
8914 
    oprot.writeStructEnd()
8915 
 
8916 
  def validate(self):
8917 
    return
8918 
 
8919 
 
8920 
  def __repr__(self):
8921 
    L = ['%s=%r' % (key, value)
8922 
      for key, value in self.__dict__.iteritems()]
8923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8924 
 
8925 
  def __eq__(self, other):
8926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8927 
 
8928 
  def __ne__(self, other):
8929 
    return not (self == other)
8930 
 
8931 
class getItem_args:
8932 
  """
8933 
  Attributes:
8934 
   - item_id
8935 
  """
8936 
 
8937 
  thrift_spec = (
8938 
    None, # 0
8939 
    (1, TType.I64, 'item_id', None, None, ), # 1
8940 
  )
8941 
 
8942 
  def __init__(self, item_id=None,):
8943 
    self.item_id = item_id
8944 
 
8945 
  def read(self, iprot):
8946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8948 
      return
8949 
    iprot.readStructBegin()
8950 
    while True:
8951 
      (fname, ftype, fid) = iprot.readFieldBegin()
8952 
      if ftype == TType.STOP:
8953 
        break
8954 
      if fid == 1:
8955 
        if ftype == TType.I64:
8956 
          self.item_id = iprot.readI64();
8957 
        else:
8958 
          iprot.skip(ftype)
8959 
      else:
8960 
        iprot.skip(ftype)
8961 
      iprot.readFieldEnd()
8962 
    iprot.readStructEnd()
8963 
 
8964 
  def write(self, oprot):
8965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8967 
      return
8968 
    oprot.writeStructBegin('getItem_args')
8969 
    if self.item_id is not None:
8970 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8971 
      oprot.writeI64(self.item_id)
8972 
      oprot.writeFieldEnd()
8973 
    oprot.writeFieldStop()
8974 
    oprot.writeStructEnd()
8975 
 
8976 
  def validate(self):
8977 
    return
8978 
 
8979 
 
8980 
  def __repr__(self):
8981 
    L = ['%s=%r' % (key, value)
8982 
      for key, value in self.__dict__.iteritems()]
8983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8984 
 
8985 
  def __eq__(self, other):
8986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8987 
 
8988 
  def __ne__(self, other):
8989 
    return not (self == other)
8990 
 
8991 
class getItem_result:
8992 
  """
8993 
  Attributes:
8994 
   - success
8995 
   - cex
8996 
  """
8997 
 
8998 
  thrift_spec = (
8999 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9000 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9001 
  )
9002 
 
9003 
  def __init__(self, success=None, cex=None,):
9004 
    self.success = success
9005 
    self.cex = cex
9006 
 
9007 
  def read(self, iprot):
9008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9010 
      return
9011 
    iprot.readStructBegin()
9012 
    while True:
9013 
      (fname, ftype, fid) = iprot.readFieldBegin()
9014 
      if ftype == TType.STOP:
9015 
        break
9016 
      if fid == 0:
9017 
        if ftype == TType.STRUCT:
9018 
          self.success = Item()
9019 
          self.success.read(iprot)
9020 
        else:
9021 
          iprot.skip(ftype)
9022 
      elif fid == 1:
9023 
        if ftype == TType.STRUCT:
9024 
          self.cex = CatalogServiceException()
9025 
          self.cex.read(iprot)
9026 
        else:
9027 
          iprot.skip(ftype)
9028 
      else:
9029 
        iprot.skip(ftype)
9030 
      iprot.readFieldEnd()
9031 
    iprot.readStructEnd()
9032 
 
9033 
  def write(self, oprot):
9034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9036 
      return
9037 
    oprot.writeStructBegin('getItem_result')
9038 
    if self.success is not None:
9039 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9040 
      self.success.write(oprot)
9041 
      oprot.writeFieldEnd()
9042 
    if self.cex is not None:
9043 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9044 
      self.cex.write(oprot)
9045 
      oprot.writeFieldEnd()
9046 
    oprot.writeFieldStop()
9047 
    oprot.writeStructEnd()
9048 
 
9049 
  def validate(self):
9050 
    return
9051 
 
9052 
 
9053 
  def __repr__(self):
9054 
    L = ['%s=%r' % (key, value)
9055 
      for key, value in self.__dict__.iteritems()]
9056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9057 
 
9058 
  def __eq__(self, other):
9059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9060 
 
9061 
  def __ne__(self, other):
9062 
    return not (self == other)
9063 
 
9064 
class getItemsByCatalogId_args:
9065 
  """
9066 
  Attributes:
9067 
   - catalog_item_id
9068 
  """
9069 
 
9070 
  thrift_spec = (
9071 
    None, # 0
9072 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
9073 
  )
9074 
 
9075 
  def __init__(self, catalog_item_id=None,):
9076 
    self.catalog_item_id = catalog_item_id
9077 
 
9078 
  def read(self, iprot):
9079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9081 
      return
9082 
    iprot.readStructBegin()
9083 
    while True:
9084 
      (fname, ftype, fid) = iprot.readFieldBegin()
9085 
      if ftype == TType.STOP:
9086 
        break
9087 
      if fid == 1:
9088 
        if ftype == TType.I64:
9089 
          self.catalog_item_id = iprot.readI64();
9090 
        else:
9091 
          iprot.skip(ftype)
9092 
      else:
9093 
        iprot.skip(ftype)
9094 
      iprot.readFieldEnd()
9095 
    iprot.readStructEnd()
9096 
 
9097 
  def write(self, oprot):
9098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9100 
      return
9101 
    oprot.writeStructBegin('getItemsByCatalogId_args')
9102 
    if self.catalog_item_id is not None:
9103 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
9104 
      oprot.writeI64(self.catalog_item_id)
9105 
      oprot.writeFieldEnd()
9106 
    oprot.writeFieldStop()
9107 
    oprot.writeStructEnd()
9108 
 
9109 
  def validate(self):
9110 
    return
9111 
 
9112 
 
9113 
  def __repr__(self):
9114 
    L = ['%s=%r' % (key, value)
9115 
      for key, value in self.__dict__.iteritems()]
9116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9117 
 
9118 
  def __eq__(self, other):
9119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9120 
 
9121 
  def __ne__(self, other):
9122 
    return not (self == other)
9123 
 
9124 
class getItemsByCatalogId_result:
9125 
  """
9126 
  Attributes:
9127 
   - success
9128 
   - cex
9129 
  """
9130 
 
9131 
  thrift_spec = (
9132 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9133 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9134 
  )
9135 
 
9136 
  def __init__(self, success=None, cex=None,):
9137 
    self.success = success
9138 
    self.cex = cex
9139 
 
9140 
  def read(self, iprot):
9141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9143 
      return
9144 
    iprot.readStructBegin()
9145 
    while True:
9146 
      (fname, ftype, fid) = iprot.readFieldBegin()
9147 
      if ftype == TType.STOP:
9148 
        break
9149 
      if fid == 0:
9150 
        if ftype == TType.LIST:
9151 
          self.success = []
8590 kshitij.so 9152 
          (_etype49, _size46) = iprot.readListBegin()
9153 
          for _i50 in xrange(_size46):
9154 
            _elem51 = Item()
9155 
            _elem51.read(iprot)
9156 
            self.success.append(_elem51)
5944 mandeep.dh 9157 
          iprot.readListEnd()
9158 
        else:
9159 
          iprot.skip(ftype)
9160 
      elif fid == 1:
9161 
        if ftype == TType.STRUCT:
9162 
          self.cex = CatalogServiceException()
9163 
          self.cex.read(iprot)
9164 
        else:
9165 
          iprot.skip(ftype)
9166 
      else:
9167 
        iprot.skip(ftype)
9168 
      iprot.readFieldEnd()
9169 
    iprot.readStructEnd()
9170 
 
9171 
  def write(self, oprot):
9172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9174 
      return
9175 
    oprot.writeStructBegin('getItemsByCatalogId_result')
9176 
    if self.success is not None:
9177 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9178 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9179 
      for iter52 in self.success:
9180 
        iter52.write(oprot)
5944 mandeep.dh 9181 
      oprot.writeListEnd()
9182 
      oprot.writeFieldEnd()
9183 
    if self.cex is not None:
9184 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9185 
      self.cex.write(oprot)
9186 
      oprot.writeFieldEnd()
9187 
    oprot.writeFieldStop()
9188 
    oprot.writeStructEnd()
9189 
 
9190 
  def validate(self):
9191 
    return
9192 
 
9193 
 
9194 
  def __repr__(self):
9195 
    L = ['%s=%r' % (key, value)
9196 
      for key, value in self.__dict__.iteritems()]
9197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9198 
 
9199 
  def __eq__(self, other):
9200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9201 
 
9202 
  def __ne__(self, other):
9203 
    return not (self == other)
9204 
 
9205 
class getValidItemsByCatalogId_args:
9206 
  """
9207 
  Attributes:
9208 
   - catalog_item_id
9209 
  """
9210 
 
9211 
  thrift_spec = (
9212 
    None, # 0
9213 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
9214 
  )
9215 
 
9216 
  def __init__(self, catalog_item_id=None,):
9217 
    self.catalog_item_id = catalog_item_id
9218 
 
9219 
  def read(self, iprot):
9220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9222 
      return
9223 
    iprot.readStructBegin()
9224 
    while True:
9225 
      (fname, ftype, fid) = iprot.readFieldBegin()
9226 
      if ftype == TType.STOP:
9227 
        break
9228 
      if fid == 1:
9229 
        if ftype == TType.I64:
9230 
          self.catalog_item_id = iprot.readI64();
9231 
        else:
9232 
          iprot.skip(ftype)
9233 
      else:
9234 
        iprot.skip(ftype)
9235 
      iprot.readFieldEnd()
9236 
    iprot.readStructEnd()
9237 
 
9238 
  def write(self, oprot):
9239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9241 
      return
9242 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
9243 
    if self.catalog_item_id is not None:
9244 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
9245 
      oprot.writeI64(self.catalog_item_id)
9246 
      oprot.writeFieldEnd()
9247 
    oprot.writeFieldStop()
9248 
    oprot.writeStructEnd()
9249 
 
9250 
  def validate(self):
9251 
    return
9252 
 
9253 
 
9254 
  def __repr__(self):
9255 
    L = ['%s=%r' % (key, value)
9256 
      for key, value in self.__dict__.iteritems()]
9257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9258 
 
9259 
  def __eq__(self, other):
9260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9261 
 
9262 
  def __ne__(self, other):
9263 
    return not (self == other)
9264 
 
9265 
class getValidItemsByCatalogId_result:
9266 
  """
9267 
  Attributes:
9268 
   - success
9269 
   - cex
9270 
  """
9271 
 
9272 
  thrift_spec = (
9273 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9274 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9275 
  )
9276 
 
9277 
  def __init__(self, success=None, cex=None,):
9278 
    self.success = success
9279 
    self.cex = cex
9280 
 
9281 
  def read(self, iprot):
9282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9284 
      return
9285 
    iprot.readStructBegin()
9286 
    while True:
9287 
      (fname, ftype, fid) = iprot.readFieldBegin()
9288 
      if ftype == TType.STOP:
9289 
        break
9290 
      if fid == 0:
9291 
        if ftype == TType.LIST:
9292 
          self.success = []
8590 kshitij.so 9293 
          (_etype56, _size53) = iprot.readListBegin()
9294 
          for _i57 in xrange(_size53):
9295 
            _elem58 = Item()
9296 
            _elem58.read(iprot)
9297 
            self.success.append(_elem58)
5944 mandeep.dh 9298 
          iprot.readListEnd()
9299 
        else:
9300 
          iprot.skip(ftype)
9301 
      elif fid == 1:
9302 
        if ftype == TType.STRUCT:
9303 
          self.cex = CatalogServiceException()
9304 
          self.cex.read(iprot)
9305 
        else:
9306 
          iprot.skip(ftype)
9307 
      else:
9308 
        iprot.skip(ftype)
9309 
      iprot.readFieldEnd()
9310 
    iprot.readStructEnd()
9311 
 
9312 
  def write(self, oprot):
9313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9315 
      return
9316 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
9317 
    if self.success is not None:
9318 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9319 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9320 
      for iter59 in self.success:
9321 
        iter59.write(oprot)
5944 mandeep.dh 9322 
      oprot.writeListEnd()
9323 
      oprot.writeFieldEnd()
9324 
    if self.cex is not None:
9325 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9326 
      self.cex.write(oprot)
9327 
      oprot.writeFieldEnd()
9328 
    oprot.writeFieldStop()
9329 
    oprot.writeStructEnd()
9330 
 
9331 
  def validate(self):
9332 
    return
9333 
 
9334 
 
9335 
  def __repr__(self):
9336 
    L = ['%s=%r' % (key, value)
9337 
      for key, value in self.__dict__.iteritems()]
9338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9339 
 
9340 
  def __eq__(self, other):
9341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9342 
 
9343 
  def __ne__(self, other):
9344 
    return not (self == other)
9345 
 
9346 
class getAllItems_args:
9347 
  """
9348 
  Attributes:
9349 
   - isActive
9350 
  """
9351 
 
9352 
  thrift_spec = (
9353 
    None, # 0
9354 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
9355 
  )
9356 
 
9357 
  def __init__(self, isActive=None,):
9358 
    self.isActive = isActive
9359 
 
9360 
  def read(self, iprot):
9361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9363 
      return
9364 
    iprot.readStructBegin()
9365 
    while True:
9366 
      (fname, ftype, fid) = iprot.readFieldBegin()
9367 
      if ftype == TType.STOP:
9368 
        break
9369 
      if fid == 1:
9370 
        if ftype == TType.BOOL:
9371 
          self.isActive = iprot.readBool();
9372 
        else:
9373 
          iprot.skip(ftype)
9374 
      else:
9375 
        iprot.skip(ftype)
9376 
      iprot.readFieldEnd()
9377 
    iprot.readStructEnd()
9378 
 
9379 
  def write(self, oprot):
9380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9382 
      return
9383 
    oprot.writeStructBegin('getAllItems_args')
9384 
    if self.isActive is not None:
9385 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
9386 
      oprot.writeBool(self.isActive)
9387 
      oprot.writeFieldEnd()
9388 
    oprot.writeFieldStop()
9389 
    oprot.writeStructEnd()
9390 
 
9391 
  def validate(self):
9392 
    return
9393 
 
9394 
 
9395 
  def __repr__(self):
9396 
    L = ['%s=%r' % (key, value)
9397 
      for key, value in self.__dict__.iteritems()]
9398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9399 
 
9400 
  def __eq__(self, other):
9401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9402 
 
9403 
  def __ne__(self, other):
9404 
    return not (self == other)
9405 
 
9406 
class getAllItems_result:
9407 
  """
9408 
  Attributes:
9409 
   - success
9410 
   - cex
9411 
  """
9412 
 
9413 
  thrift_spec = (
9414 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9415 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9416 
  )
9417 
 
9418 
  def __init__(self, success=None, cex=None,):
9419 
    self.success = success
9420 
    self.cex = cex
9421 
 
9422 
  def read(self, iprot):
9423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9425 
      return
9426 
    iprot.readStructBegin()
9427 
    while True:
9428 
      (fname, ftype, fid) = iprot.readFieldBegin()
9429 
      if ftype == TType.STOP:
9430 
        break
9431 
      if fid == 0:
9432 
        if ftype == TType.LIST:
9433 
          self.success = []
8590 kshitij.so 9434 
          (_etype63, _size60) = iprot.readListBegin()
9435 
          for _i64 in xrange(_size60):
9436 
            _elem65 = Item()
9437 
            _elem65.read(iprot)
9438 
            self.success.append(_elem65)
5944 mandeep.dh 9439 
          iprot.readListEnd()
9440 
        else:
9441 
          iprot.skip(ftype)
9442 
      elif fid == 1:
9443 
        if ftype == TType.STRUCT:
9444 
          self.cex = CatalogServiceException()
9445 
          self.cex.read(iprot)
9446 
        else:
9447 
          iprot.skip(ftype)
9448 
      else:
9449 
        iprot.skip(ftype)
9450 
      iprot.readFieldEnd()
9451 
    iprot.readStructEnd()
9452 
 
9453 
  def write(self, oprot):
9454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9456 
      return
9457 
    oprot.writeStructBegin('getAllItems_result')
9458 
    if self.success is not None:
9459 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9460 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9461 
      for iter66 in self.success:
9462 
        iter66.write(oprot)
5944 mandeep.dh 9463 
      oprot.writeListEnd()
9464 
      oprot.writeFieldEnd()
9465 
    if self.cex is not None:
9466 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9467 
      self.cex.write(oprot)
9468 
      oprot.writeFieldEnd()
9469 
    oprot.writeFieldStop()
9470 
    oprot.writeStructEnd()
9471 
 
9472 
  def validate(self):
9473 
    return
9474 
 
9475 
 
9476 
  def __repr__(self):
9477 
    L = ['%s=%r' % (key, value)
9478 
      for key, value in self.__dict__.iteritems()]
9479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9480 
 
9481 
  def __eq__(self, other):
9482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9483 
 
9484 
  def __ne__(self, other):
9485 
    return not (self == other)
9486 
 
9487 
class getAllItemsByStatus_args:
9488 
  """
9489 
  Attributes:
9490 
   - itemStatus
9491 
  """
9492 
 
9493 
  thrift_spec = (
9494 
    None, # 0
9495 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9496 
  )
9497 
 
9498 
  def __init__(self, itemStatus=None,):
9499 
    self.itemStatus = itemStatus
9500 
 
9501 
  def read(self, iprot):
9502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9504 
      return
9505 
    iprot.readStructBegin()
9506 
    while True:
9507 
      (fname, ftype, fid) = iprot.readFieldBegin()
9508 
      if ftype == TType.STOP:
9509 
        break
9510 
      if fid == 1:
9511 
        if ftype == TType.I32:
9512 
          self.itemStatus = iprot.readI32();
9513 
        else:
9514 
          iprot.skip(ftype)
9515 
      else:
9516 
        iprot.skip(ftype)
9517 
      iprot.readFieldEnd()
9518 
    iprot.readStructEnd()
9519 
 
9520 
  def write(self, oprot):
9521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9523 
      return
9524 
    oprot.writeStructBegin('getAllItemsByStatus_args')
9525 
    if self.itemStatus is not None:
9526 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9527 
      oprot.writeI32(self.itemStatus)
9528 
      oprot.writeFieldEnd()
9529 
    oprot.writeFieldStop()
9530 
    oprot.writeStructEnd()
9531 
 
9532 
  def validate(self):
9533 
    return
9534 
 
9535 
 
9536 
  def __repr__(self):
9537 
    L = ['%s=%r' % (key, value)
9538 
      for key, value in self.__dict__.iteritems()]
9539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9540 
 
9541 
  def __eq__(self, other):
9542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9543 
 
9544 
  def __ne__(self, other):
9545 
    return not (self == other)
9546 
 
9547 
class getAllItemsByStatus_result:
9548 
  """
9549 
  Attributes:
9550 
   - success
9551 
   - cex
9552 
  """
9553 
 
9554 
  thrift_spec = (
9555 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9556 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9557 
  )
9558 
 
9559 
  def __init__(self, success=None, cex=None,):
9560 
    self.success = success
9561 
    self.cex = cex
9562 
 
9563 
  def read(self, iprot):
9564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9566 
      return
9567 
    iprot.readStructBegin()
9568 
    while True:
9569 
      (fname, ftype, fid) = iprot.readFieldBegin()
9570 
      if ftype == TType.STOP:
9571 
        break
9572 
      if fid == 0:
9573 
        if ftype == TType.LIST:
9574 
          self.success = []
8590 kshitij.so 9575 
          (_etype70, _size67) = iprot.readListBegin()
9576 
          for _i71 in xrange(_size67):
9577 
            _elem72 = Item()
9578 
            _elem72.read(iprot)
9579 
            self.success.append(_elem72)
5944 mandeep.dh 9580 
          iprot.readListEnd()
9581 
        else:
9582 
          iprot.skip(ftype)
9583 
      elif fid == 1:
9584 
        if ftype == TType.STRUCT:
9585 
          self.cex = CatalogServiceException()
9586 
          self.cex.read(iprot)
9587 
        else:
9588 
          iprot.skip(ftype)
9589 
      else:
9590 
        iprot.skip(ftype)
9591 
      iprot.readFieldEnd()
9592 
    iprot.readStructEnd()
9593 
 
9594 
  def write(self, oprot):
9595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9597 
      return
9598 
    oprot.writeStructBegin('getAllItemsByStatus_result')
9599 
    if self.success is not None:
9600 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9601 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9602 
      for iter73 in self.success:
9603 
        iter73.write(oprot)
5944 mandeep.dh 9604 
      oprot.writeListEnd()
9605 
      oprot.writeFieldEnd()
9606 
    if self.cex is not None:
9607 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9608 
      self.cex.write(oprot)
9609 
      oprot.writeFieldEnd()
9610 
    oprot.writeFieldStop()
9611 
    oprot.writeStructEnd()
9612 
 
9613 
  def validate(self):
9614 
    return
9615 
 
9616 
 
9617 
  def __repr__(self):
9618 
    L = ['%s=%r' % (key, value)
9619 
      for key, value in self.__dict__.iteritems()]
9620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9621 
 
9622 
  def __eq__(self, other):
9623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9624 
 
9625 
  def __ne__(self, other):
9626 
    return not (self == other)
9627 
 
9628 
class markItemAsContentComplete_args:
9629 
  """
9630 
  Attributes:
9631 
   - entityId
9632 
   - category
9633 
   - brand
9634 
   - modelName
9635 
   - modelNumber
9253 rajveer 9636 
   - isAndroid
5944 mandeep.dh 9637 
  """
9638 
 
9639 
  thrift_spec = (
9640 
    None, # 0
9641 
    (1, TType.I64, 'entityId', None, None, ), # 1
9642 
    (2, TType.I64, 'category', None, None, ), # 2
9643 
    (3, TType.STRING, 'brand', None, None, ), # 3
9644 
    (4, TType.STRING, 'modelName', None, None, ), # 4
9645 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 9646 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 9647 
  )
9648 
 
9253 rajveer 9649 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 9650 
    self.entityId = entityId
9651 
    self.category = category
9652 
    self.brand = brand
9653 
    self.modelName = modelName
9654 
    self.modelNumber = modelNumber
9253 rajveer 9655 
    self.isAndroid = isAndroid
5944 mandeep.dh 9656 
 
9657 
  def read(self, iprot):
9658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9660 
      return
9661 
    iprot.readStructBegin()
9662 
    while True:
9663 
      (fname, ftype, fid) = iprot.readFieldBegin()
9664 
      if ftype == TType.STOP:
9665 
        break
9666 
      if fid == 1:
9667 
        if ftype == TType.I64:
9668 
          self.entityId = iprot.readI64();
9669 
        else:
9670 
          iprot.skip(ftype)
9671 
      elif fid == 2:
9672 
        if ftype == TType.I64:
9673 
          self.category = iprot.readI64();
9674 
        else:
9675 
          iprot.skip(ftype)
9676 
      elif fid == 3:
9677 
        if ftype == TType.STRING:
9678 
          self.brand = iprot.readString();
9679 
        else:
9680 
          iprot.skip(ftype)
9681 
      elif fid == 4:
9682 
        if ftype == TType.STRING:
9683 
          self.modelName = iprot.readString();
9684 
        else:
9685 
          iprot.skip(ftype)
9686 
      elif fid == 5:
9687 
        if ftype == TType.STRING:
9688 
          self.modelNumber = iprot.readString();
9689 
        else:
9690 
          iprot.skip(ftype)
9253 rajveer 9691 
      elif fid == 6:
9692 
        if ftype == TType.BOOL:
9693 
          self.isAndroid = iprot.readBool();
9694 
        else:
9695 
          iprot.skip(ftype)
5944 mandeep.dh 9696 
      else:
9697 
        iprot.skip(ftype)
9698 
      iprot.readFieldEnd()
9699 
    iprot.readStructEnd()
9700 
 
9701 
  def write(self, oprot):
9702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9704 
      return
9705 
    oprot.writeStructBegin('markItemAsContentComplete_args')
9706 
    if self.entityId is not None:
9707 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
9708 
      oprot.writeI64(self.entityId)
9709 
      oprot.writeFieldEnd()
9710 
    if self.category is not None:
9711 
      oprot.writeFieldBegin('category', TType.I64, 2)
9712 
      oprot.writeI64(self.category)
9713 
      oprot.writeFieldEnd()
9714 
    if self.brand is not None:
9715 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9716 
      oprot.writeString(self.brand)
9717 
      oprot.writeFieldEnd()
9718 
    if self.modelName is not None:
9719 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
9720 
      oprot.writeString(self.modelName)
9721 
      oprot.writeFieldEnd()
9722 
    if self.modelNumber is not None:
9723 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
9724 
      oprot.writeString(self.modelNumber)
9725 
      oprot.writeFieldEnd()
9253 rajveer 9726 
    if self.isAndroid is not None:
9727 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
9728 
      oprot.writeBool(self.isAndroid)
9729 
      oprot.writeFieldEnd()
5944 mandeep.dh 9730 
    oprot.writeFieldStop()
9731 
    oprot.writeStructEnd()
9732 
 
9733 
  def validate(self):
9734 
    return
9735 
 
9736 
 
9737 
  def __repr__(self):
9738 
    L = ['%s=%r' % (key, value)
9739 
      for key, value in self.__dict__.iteritems()]
9740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9741 
 
9742 
  def __eq__(self, other):
9743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9744 
 
9745 
  def __ne__(self, other):
9746 
    return not (self == other)
9747 
 
9748 
class markItemAsContentComplete_result:
9749 
  """
9750 
  Attributes:
9751 
   - success
9752 
   - cex
9753 
  """
9754 
 
9755 
  thrift_spec = (
9756 
    (0, TType.BOOL, 'success', None, None, ), # 0
9757 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9758 
  )
9759 
 
9760 
  def __init__(self, success=None, cex=None,):
9761 
    self.success = success
9762 
    self.cex = cex
9763 
 
9764 
  def read(self, iprot):
9765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9767 
      return
9768 
    iprot.readStructBegin()
9769 
    while True:
9770 
      (fname, ftype, fid) = iprot.readFieldBegin()
9771 
      if ftype == TType.STOP:
9772 
        break
9773 
      if fid == 0:
9774 
        if ftype == TType.BOOL:
9775 
          self.success = iprot.readBool();
9776 
        else:
9777 
          iprot.skip(ftype)
9778 
      elif fid == 1:
9779 
        if ftype == TType.STRUCT:
9780 
          self.cex = CatalogServiceException()
9781 
          self.cex.read(iprot)
9782 
        else:
9783 
          iprot.skip(ftype)
9784 
      else:
9785 
        iprot.skip(ftype)
9786 
      iprot.readFieldEnd()
9787 
    iprot.readStructEnd()
9788 
 
9789 
  def write(self, oprot):
9790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9792 
      return
9793 
    oprot.writeStructBegin('markItemAsContentComplete_result')
9794 
    if self.success is not None:
9795 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9796 
      oprot.writeBool(self.success)
9797 
      oprot.writeFieldEnd()
9798 
    if self.cex is not None:
9799 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9800 
      self.cex.write(oprot)
9801 
      oprot.writeFieldEnd()
9802 
    oprot.writeFieldStop()
9803 
    oprot.writeStructEnd()
9804 
 
9805 
  def validate(self):
9806 
    return
9807 
 
9808 
 
9809 
  def __repr__(self):
9810 
    L = ['%s=%r' % (key, value)
9811 
      for key, value in self.__dict__.iteritems()]
9812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9813 
 
9814 
  def __eq__(self, other):
9815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9816 
 
9817 
  def __ne__(self, other):
9818 
    return not (self == other)
9819 
 
9820 
class getAllItemsInRange_args:
9821 
  """
9822 
  Attributes:
9823 
   - offset
9824 
   - limit
9825 
  """
9826 
 
9827 
  thrift_spec = (
9828 
    None, # 0
9829 
    (1, TType.I64, 'offset', None, None, ), # 1
9830 
    (2, TType.I64, 'limit', None, None, ), # 2
9831 
  )
9832 
 
9833 
  def __init__(self, offset=None, limit=None,):
9834 
    self.offset = offset
9835 
    self.limit = limit
9836 
 
9837 
  def read(self, iprot):
9838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9840 
      return
9841 
    iprot.readStructBegin()
9842 
    while True:
9843 
      (fname, ftype, fid) = iprot.readFieldBegin()
9844 
      if ftype == TType.STOP:
9845 
        break
9846 
      if fid == 1:
9847 
        if ftype == TType.I64:
9848 
          self.offset = iprot.readI64();
9849 
        else:
9850 
          iprot.skip(ftype)
9851 
      elif fid == 2:
9852 
        if ftype == TType.I64:
9853 
          self.limit = iprot.readI64();
9854 
        else:
9855 
          iprot.skip(ftype)
9856 
      else:
9857 
        iprot.skip(ftype)
9858 
      iprot.readFieldEnd()
9859 
    iprot.readStructEnd()
9860 
 
9861 
  def write(self, oprot):
9862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9864 
      return
9865 
    oprot.writeStructBegin('getAllItemsInRange_args')
9866 
    if self.offset is not None:
9867 
      oprot.writeFieldBegin('offset', TType.I64, 1)
9868 
      oprot.writeI64(self.offset)
9869 
      oprot.writeFieldEnd()
9870 
    if self.limit is not None:
9871 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9872 
      oprot.writeI64(self.limit)
9873 
      oprot.writeFieldEnd()
9874 
    oprot.writeFieldStop()
9875 
    oprot.writeStructEnd()
9876 
 
9877 
  def validate(self):
9878 
    return
9879 
 
9880 
 
9881 
  def __repr__(self):
9882 
    L = ['%s=%r' % (key, value)
9883 
      for key, value in self.__dict__.iteritems()]
9884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9885 
 
9886 
  def __eq__(self, other):
9887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9888 
 
9889 
  def __ne__(self, other):
9890 
    return not (self == other)
9891 
 
9892 
class getAllItemsInRange_result:
9893 
  """
9894 
  Attributes:
9895 
   - success
9896 
   - cex
9897 
  """
9898 
 
9899 
  thrift_spec = (
9900 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9901 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9902 
  )
9903 
 
9904 
  def __init__(self, success=None, cex=None,):
9905 
    self.success = success
9906 
    self.cex = cex
9907 
 
9908 
  def read(self, iprot):
9909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9911 
      return
9912 
    iprot.readStructBegin()
9913 
    while True:
9914 
      (fname, ftype, fid) = iprot.readFieldBegin()
9915 
      if ftype == TType.STOP:
9916 
        break
9917 
      if fid == 0:
9918 
        if ftype == TType.LIST:
9919 
          self.success = []
8590 kshitij.so 9920 
          (_etype77, _size74) = iprot.readListBegin()
9921 
          for _i78 in xrange(_size74):
9922 
            _elem79 = Item()
9923 
            _elem79.read(iprot)
9924 
            self.success.append(_elem79)
5944 mandeep.dh 9925 
          iprot.readListEnd()
9926 
        else:
9927 
          iprot.skip(ftype)
9928 
      elif fid == 1:
9929 
        if ftype == TType.STRUCT:
9930 
          self.cex = CatalogServiceException()
9931 
          self.cex.read(iprot)
9932 
        else:
9933 
          iprot.skip(ftype)
9934 
      else:
9935 
        iprot.skip(ftype)
9936 
      iprot.readFieldEnd()
9937 
    iprot.readStructEnd()
9938 
 
9939 
  def write(self, oprot):
9940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9942 
      return
9943 
    oprot.writeStructBegin('getAllItemsInRange_result')
9944 
    if self.success is not None:
9945 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9946 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9947 
      for iter80 in self.success:
9948 
        iter80.write(oprot)
5944 mandeep.dh 9949 
      oprot.writeListEnd()
9950 
      oprot.writeFieldEnd()
9951 
    if self.cex is not None:
9952 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9953 
      self.cex.write(oprot)
9954 
      oprot.writeFieldEnd()
9955 
    oprot.writeFieldStop()
9956 
    oprot.writeStructEnd()
9957 
 
9958 
  def validate(self):
9959 
    return
9960 
 
9961 
 
9962 
  def __repr__(self):
9963 
    L = ['%s=%r' % (key, value)
9964 
      for key, value in self.__dict__.iteritems()]
9965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9966 
 
9967 
  def __eq__(self, other):
9968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9969 
 
9970 
  def __ne__(self, other):
9971 
    return not (self == other)
9972 
 
9973 
class getAllItemsByStatusInRange_args:
9974 
  """
9975 
  Attributes:
9976 
   - itemStatus
9977 
   - offset
9978 
   - limit
9979 
  """
9980 
 
9981 
  thrift_spec = (
9982 
    None, # 0
9983 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9984 
    (2, TType.I64, 'offset', None, None, ), # 2
9985 
    (3, TType.I64, 'limit', None, None, ), # 3
9986 
  )
9987 
 
9988 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
9989 
    self.itemStatus = itemStatus
9990 
    self.offset = offset
9991 
    self.limit = limit
9992 
 
9993 
  def read(self, iprot):
9994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9996 
      return
9997 
    iprot.readStructBegin()
9998 
    while True:
9999 
      (fname, ftype, fid) = iprot.readFieldBegin()
10000 
      if ftype == TType.STOP:
10001 
        break
10002 
      if fid == 1:
10003 
        if ftype == TType.I32:
10004 
          self.itemStatus = iprot.readI32();
10005 
        else:
10006 
          iprot.skip(ftype)
10007 
      elif fid == 2:
10008 
        if ftype == TType.I64:
10009 
          self.offset = iprot.readI64();
10010 
        else:
10011 
          iprot.skip(ftype)
10012 
      elif fid == 3:
10013 
        if ftype == TType.I64:
10014 
          self.limit = iprot.readI64();
10015 
        else:
10016 
          iprot.skip(ftype)
10017 
      else:
10018 
        iprot.skip(ftype)
10019 
      iprot.readFieldEnd()
10020 
    iprot.readStructEnd()
10021 
 
10022 
  def write(self, oprot):
10023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10025 
      return
10026 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
10027 
    if self.itemStatus is not None:
10028 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
10029 
      oprot.writeI32(self.itemStatus)
10030 
      oprot.writeFieldEnd()
10031 
    if self.offset is not None:
10032 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10033 
      oprot.writeI64(self.offset)
10034 
      oprot.writeFieldEnd()
10035 
    if self.limit is not None:
10036 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10037 
      oprot.writeI64(self.limit)
10038 
      oprot.writeFieldEnd()
10039 
    oprot.writeFieldStop()
10040 
    oprot.writeStructEnd()
10041 
 
10042 
  def validate(self):
10043 
    return
10044 
 
10045 
 
10046 
  def __repr__(self):
10047 
    L = ['%s=%r' % (key, value)
10048 
      for key, value in self.__dict__.iteritems()]
10049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10050 
 
10051 
  def __eq__(self, other):
10052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10053 
 
10054 
  def __ne__(self, other):
10055 
    return not (self == other)
10056 
 
10057 
class getAllItemsByStatusInRange_result:
10058 
  """
10059 
  Attributes:
10060 
   - success
10061 
   - cex
10062 
  """
10063 
 
10064 
  thrift_spec = (
10065 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10066 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10067 
  )
10068 
 
10069 
  def __init__(self, success=None, cex=None,):
10070 
    self.success = success
10071 
    self.cex = cex
10072 
 
10073 
  def read(self, iprot):
10074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10076 
      return
10077 
    iprot.readStructBegin()
10078 
    while True:
10079 
      (fname, ftype, fid) = iprot.readFieldBegin()
10080 
      if ftype == TType.STOP:
10081 
        break
10082 
      if fid == 0:
10083 
        if ftype == TType.LIST:
10084 
          self.success = []
8590 kshitij.so 10085 
          (_etype84, _size81) = iprot.readListBegin()
10086 
          for _i85 in xrange(_size81):
10087 
            _elem86 = Item()
10088 
            _elem86.read(iprot)
10089 
            self.success.append(_elem86)
5944 mandeep.dh 10090 
          iprot.readListEnd()
10091 
        else:
10092 
          iprot.skip(ftype)
10093 
      elif fid == 1:
10094 
        if ftype == TType.STRUCT:
10095 
          self.cex = CatalogServiceException()
10096 
          self.cex.read(iprot)
10097 
        else:
10098 
          iprot.skip(ftype)
10099 
      else:
10100 
        iprot.skip(ftype)
10101 
      iprot.readFieldEnd()
10102 
    iprot.readStructEnd()
10103 
 
10104 
  def write(self, oprot):
10105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10107 
      return
10108 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
10109 
    if self.success is not None:
10110 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10111 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10112 
      for iter87 in self.success:
10113 
        iter87.write(oprot)
5944 mandeep.dh 10114 
      oprot.writeListEnd()
10115 
      oprot.writeFieldEnd()
10116 
    if self.cex is not None:
10117 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10118 
      self.cex.write(oprot)
10119 
      oprot.writeFieldEnd()
10120 
    oprot.writeFieldStop()
10121 
    oprot.writeStructEnd()
10122 
 
10123 
  def validate(self):
10124 
    return
10125 
 
10126 
 
10127 
  def __repr__(self):
10128 
    L = ['%s=%r' % (key, value)
10129 
      for key, value in self.__dict__.iteritems()]
10130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10131 
 
10132 
  def __eq__(self, other):
10133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10134 
 
10135 
  def __ne__(self, other):
10136 
    return not (self == other)
10137 
 
10138 
class getItemCountByStatus_args:
10139 
  """
10140 
  Attributes:
10141 
   - useStatus
10142 
   - itemStatus
10143 
  """
10144 
 
10145 
  thrift_spec = (
10146 
    None, # 0
10147 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
10148 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
10149 
  )
10150 
 
10151 
  def __init__(self, useStatus=None, itemStatus=None,):
10152 
    self.useStatus = useStatus
10153 
    self.itemStatus = itemStatus
10154 
 
10155 
  def read(self, iprot):
10156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10158 
      return
10159 
    iprot.readStructBegin()
10160 
    while True:
10161 
      (fname, ftype, fid) = iprot.readFieldBegin()
10162 
      if ftype == TType.STOP:
10163 
        break
10164 
      if fid == 1:
10165 
        if ftype == TType.BOOL:
10166 
          self.useStatus = iprot.readBool();
10167 
        else:
10168 
          iprot.skip(ftype)
10169 
      elif fid == 2:
10170 
        if ftype == TType.I32:
10171 
          self.itemStatus = iprot.readI32();
10172 
        else:
10173 
          iprot.skip(ftype)
10174 
      else:
10175 
        iprot.skip(ftype)
10176 
      iprot.readFieldEnd()
10177 
    iprot.readStructEnd()
10178 
 
10179 
  def write(self, oprot):
10180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10182 
      return
10183 
    oprot.writeStructBegin('getItemCountByStatus_args')
10184 
    if self.useStatus is not None:
10185 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
10186 
      oprot.writeBool(self.useStatus)
10187 
      oprot.writeFieldEnd()
10188 
    if self.itemStatus is not None:
10189 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
10190 
      oprot.writeI32(self.itemStatus)
10191 
      oprot.writeFieldEnd()
10192 
    oprot.writeFieldStop()
10193 
    oprot.writeStructEnd()
10194 
 
10195 
  def validate(self):
10196 
    return
10197 
 
10198 
 
10199 
  def __repr__(self):
10200 
    L = ['%s=%r' % (key, value)
10201 
      for key, value in self.__dict__.iteritems()]
10202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10203 
 
10204 
  def __eq__(self, other):
10205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10206 
 
10207 
  def __ne__(self, other):
10208 
    return not (self == other)
10209 
 
10210 
class getItemCountByStatus_result:
10211 
  """
10212 
  Attributes:
10213 
   - success
10214 
  """
10215 
 
10216 
  thrift_spec = (
10217 
    (0, TType.I32, 'success', None, None, ), # 0
10218 
  )
10219 
 
10220 
  def __init__(self, success=None,):
10221 
    self.success = success
10222 
 
10223 
  def read(self, iprot):
10224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10226 
      return
10227 
    iprot.readStructBegin()
10228 
    while True:
10229 
      (fname, ftype, fid) = iprot.readFieldBegin()
10230 
      if ftype == TType.STOP:
10231 
        break
10232 
      if fid == 0:
10233 
        if ftype == TType.I32:
10234 
          self.success = iprot.readI32();
10235 
        else:
10236 
          iprot.skip(ftype)
10237 
      else:
10238 
        iprot.skip(ftype)
10239 
      iprot.readFieldEnd()
10240 
    iprot.readStructEnd()
10241 
 
10242 
  def write(self, oprot):
10243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10245 
      return
10246 
    oprot.writeStructBegin('getItemCountByStatus_result')
10247 
    if self.success is not None:
10248 
      oprot.writeFieldBegin('success', TType.I32, 0)
10249 
      oprot.writeI32(self.success)
10250 
      oprot.writeFieldEnd()
10251 
    oprot.writeFieldStop()
10252 
    oprot.writeStructEnd()
10253 
 
10254 
  def validate(self):
10255 
    return
10256 
 
10257 
 
10258 
  def __repr__(self):
10259 
    L = ['%s=%r' % (key, value)
10260 
      for key, value in self.__dict__.iteritems()]
10261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10262 
 
10263 
  def __eq__(self, other):
10264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10265 
 
10266 
  def __ne__(self, other):
10267 
    return not (self == other)
10268 
 
10269 
class getBestSellers_args:
10270 
 
10271 
  thrift_spec = (
10272 
  )
10273 
 
10274 
  def read(self, iprot):
10275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10277 
      return
10278 
    iprot.readStructBegin()
10279 
    while True:
10280 
      (fname, ftype, fid) = iprot.readFieldBegin()
10281 
      if ftype == TType.STOP:
10282 
        break
10283 
      else:
10284 
        iprot.skip(ftype)
10285 
      iprot.readFieldEnd()
10286 
    iprot.readStructEnd()
10287 
 
10288 
  def write(self, oprot):
10289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10291 
      return
10292 
    oprot.writeStructBegin('getBestSellers_args')
10293 
    oprot.writeFieldStop()
10294 
    oprot.writeStructEnd()
10295 
 
10296 
  def validate(self):
10297 
    return
10298 
 
10299 
 
10300 
  def __repr__(self):
10301 
    L = ['%s=%r' % (key, value)
10302 
      for key, value in self.__dict__.iteritems()]
10303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10304 
 
10305 
  def __eq__(self, other):
10306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10307 
 
10308 
  def __ne__(self, other):
10309 
    return not (self == other)
10310 
 
10311 
class getBestSellers_result:
10312 
  """
10313 
  Attributes:
10314 
   - success
10315 
   - isex
10316 
  """
10317 
 
10318 
  thrift_spec = (
10319 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10320 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10321 
  )
10322 
 
10323 
  def __init__(self, success=None, isex=None,):
10324 
    self.success = success
10325 
    self.isex = isex
10326 
 
10327 
  def read(self, iprot):
10328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10330 
      return
10331 
    iprot.readStructBegin()
10332 
    while True:
10333 
      (fname, ftype, fid) = iprot.readFieldBegin()
10334 
      if ftype == TType.STOP:
10335 
        break
10336 
      if fid == 0:
10337 
        if ftype == TType.LIST:
10338 
          self.success = []
8590 kshitij.so 10339 
          (_etype91, _size88) = iprot.readListBegin()
10340 
          for _i92 in xrange(_size88):
10341 
            _elem93 = Item()
10342 
            _elem93.read(iprot)
10343 
            self.success.append(_elem93)
5944 mandeep.dh 10344 
          iprot.readListEnd()
10345 
        else:
10346 
          iprot.skip(ftype)
10347 
      elif fid == 1:
10348 
        if ftype == TType.STRUCT:
10349 
          self.isex = CatalogServiceException()
10350 
          self.isex.read(iprot)
10351 
        else:
10352 
          iprot.skip(ftype)
10353 
      else:
10354 
        iprot.skip(ftype)
10355 
      iprot.readFieldEnd()
10356 
    iprot.readStructEnd()
10357 
 
10358 
  def write(self, oprot):
10359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10361 
      return
10362 
    oprot.writeStructBegin('getBestSellers_result')
10363 
    if self.success is not None:
10364 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10365 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10366 
      for iter94 in self.success:
10367 
        iter94.write(oprot)
5944 mandeep.dh 10368 
      oprot.writeListEnd()
10369 
      oprot.writeFieldEnd()
10370 
    if self.isex is not None:
10371 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10372 
      self.isex.write(oprot)
10373 
      oprot.writeFieldEnd()
10374 
    oprot.writeFieldStop()
10375 
    oprot.writeStructEnd()
10376 
 
10377 
  def validate(self):
10378 
    return
10379 
 
10380 
 
10381 
  def __repr__(self):
10382 
    L = ['%s=%r' % (key, value)
10383 
      for key, value in self.__dict__.iteritems()]
10384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10385 
 
10386 
  def __eq__(self, other):
10387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10388 
 
10389 
  def __ne__(self, other):
10390 
    return not (self == other)
10391 
 
10392 
class getBestSellersCatalogIds_args:
10393 
  """
10394 
  Attributes:
10395 
   - beginIndex
10396 
   - totalItems
10397 
   - brand
10398 
   - category
10399 
  """
10400 
 
10401 
  thrift_spec = (
10402 
    None, # 0
10403 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10404 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10405 
    (3, TType.STRING, 'brand', None, None, ), # 3
10406 
    (4, TType.I64, 'category', None, None, ), # 4
10407 
  )
10408 
 
10409 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10410 
    self.beginIndex = beginIndex
10411 
    self.totalItems = totalItems
10412 
    self.brand = brand
10413 
    self.category = category
10414 
 
10415 
  def read(self, iprot):
10416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10418 
      return
10419 
    iprot.readStructBegin()
10420 
    while True:
10421 
      (fname, ftype, fid) = iprot.readFieldBegin()
10422 
      if ftype == TType.STOP:
10423 
        break
10424 
      if fid == 1:
10425 
        if ftype == TType.I64:
10426 
          self.beginIndex = iprot.readI64();
10427 
        else:
10428 
          iprot.skip(ftype)
10429 
      elif fid == 2:
10430 
        if ftype == TType.I64:
10431 
          self.totalItems = iprot.readI64();
10432 
        else:
10433 
          iprot.skip(ftype)
10434 
      elif fid == 3:
10435 
        if ftype == TType.STRING:
10436 
          self.brand = iprot.readString();
10437 
        else:
10438 
          iprot.skip(ftype)
10439 
      elif fid == 4:
10440 
        if ftype == TType.I64:
10441 
          self.category = iprot.readI64();
10442 
        else:
10443 
          iprot.skip(ftype)
10444 
      else:
10445 
        iprot.skip(ftype)
10446 
      iprot.readFieldEnd()
10447 
    iprot.readStructEnd()
10448 
 
10449 
  def write(self, oprot):
10450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10452 
      return
10453 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
10454 
    if self.beginIndex is not None:
10455 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10456 
      oprot.writeI64(self.beginIndex)
10457 
      oprot.writeFieldEnd()
10458 
    if self.totalItems is not None:
10459 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10460 
      oprot.writeI64(self.totalItems)
10461 
      oprot.writeFieldEnd()
10462 
    if self.brand is not None:
10463 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10464 
      oprot.writeString(self.brand)
10465 
      oprot.writeFieldEnd()
10466 
    if self.category is not None:
10467 
      oprot.writeFieldBegin('category', TType.I64, 4)
10468 
      oprot.writeI64(self.category)
10469 
      oprot.writeFieldEnd()
10470 
    oprot.writeFieldStop()
10471 
    oprot.writeStructEnd()
10472 
 
10473 
  def validate(self):
10474 
    return
10475 
 
10476 
 
10477 
  def __repr__(self):
10478 
    L = ['%s=%r' % (key, value)
10479 
      for key, value in self.__dict__.iteritems()]
10480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10481 
 
10482 
  def __eq__(self, other):
10483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10484 
 
10485 
  def __ne__(self, other):
10486 
    return not (self == other)
10487 
 
10488 
class getBestSellersCatalogIds_result:
10489 
  """
10490 
  Attributes:
10491 
   - success
10492 
   - cex
10493 
  """
10494 
 
10495 
  thrift_spec = (
10496 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10497 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10498 
  )
10499 
 
10500 
  def __init__(self, success=None, cex=None,):
10501 
    self.success = success
10502 
    self.cex = cex
10503 
 
10504 
  def read(self, iprot):
10505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10507 
      return
10508 
    iprot.readStructBegin()
10509 
    while True:
10510 
      (fname, ftype, fid) = iprot.readFieldBegin()
10511 
      if ftype == TType.STOP:
10512 
        break
10513 
      if fid == 0:
10514 
        if ftype == TType.LIST:
10515 
          self.success = []
8590 kshitij.so 10516 
          (_etype98, _size95) = iprot.readListBegin()
10517 
          for _i99 in xrange(_size95):
10518 
            _elem100 = iprot.readI64();
10519 
            self.success.append(_elem100)
5944 mandeep.dh 10520 
          iprot.readListEnd()
10521 
        else:
10522 
          iprot.skip(ftype)
10523 
      elif fid == 1:
10524 
        if ftype == TType.STRUCT:
10525 
          self.cex = CatalogServiceException()
10526 
          self.cex.read(iprot)
10527 
        else:
10528 
          iprot.skip(ftype)
10529 
      else:
10530 
        iprot.skip(ftype)
10531 
      iprot.readFieldEnd()
10532 
    iprot.readStructEnd()
10533 
 
10534 
  def write(self, oprot):
10535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10537 
      return
10538 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
10539 
    if self.success is not None:
10540 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10541 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10542 
      for iter101 in self.success:
10543 
        oprot.writeI64(iter101)
5944 mandeep.dh 10544 
      oprot.writeListEnd()
10545 
      oprot.writeFieldEnd()
10546 
    if self.cex is not None:
10547 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10548 
      self.cex.write(oprot)
10549 
      oprot.writeFieldEnd()
10550 
    oprot.writeFieldStop()
10551 
    oprot.writeStructEnd()
10552 
 
10553 
  def validate(self):
10554 
    return
10555 
 
10556 
 
10557 
  def __repr__(self):
10558 
    L = ['%s=%r' % (key, value)
10559 
      for key, value in self.__dict__.iteritems()]
10560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10561 
 
10562 
  def __eq__(self, other):
10563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10564 
 
10565 
  def __ne__(self, other):
10566 
    return not (self == other)
10567 
 
10568 
class getBestSellersCount_args:
10569 
 
10570 
  thrift_spec = (
10571 
  )
10572 
 
10573 
  def read(self, iprot):
10574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10576 
      return
10577 
    iprot.readStructBegin()
10578 
    while True:
10579 
      (fname, ftype, fid) = iprot.readFieldBegin()
10580 
      if ftype == TType.STOP:
10581 
        break
10582 
      else:
10583 
        iprot.skip(ftype)
10584 
      iprot.readFieldEnd()
10585 
    iprot.readStructEnd()
10586 
 
10587 
  def write(self, oprot):
10588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10590 
      return
10591 
    oprot.writeStructBegin('getBestSellersCount_args')
10592 
    oprot.writeFieldStop()
10593 
    oprot.writeStructEnd()
10594 
 
10595 
  def validate(self):
10596 
    return
10597 
 
10598 
 
10599 
  def __repr__(self):
10600 
    L = ['%s=%r' % (key, value)
10601 
      for key, value in self.__dict__.iteritems()]
10602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10603 
 
10604 
  def __eq__(self, other):
10605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10606 
 
10607 
  def __ne__(self, other):
10608 
    return not (self == other)
10609 
 
10610 
class getBestSellersCount_result:
10611 
  """
10612 
  Attributes:
10613 
   - success
10614 
   - cex
10615 
  """
10616 
 
10617 
  thrift_spec = (
10618 
    (0, TType.I64, 'success', None, None, ), # 0
10619 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10620 
  )
10621 
 
10622 
  def __init__(self, success=None, cex=None,):
10623 
    self.success = success
10624 
    self.cex = cex
10625 
 
10626 
  def read(self, iprot):
10627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10629 
      return
10630 
    iprot.readStructBegin()
10631 
    while True:
10632 
      (fname, ftype, fid) = iprot.readFieldBegin()
10633 
      if ftype == TType.STOP:
10634 
        break
10635 
      if fid == 0:
10636 
        if ftype == TType.I64:
10637 
          self.success = iprot.readI64();
10638 
        else:
10639 
          iprot.skip(ftype)
10640 
      elif fid == 1:
10641 
        if ftype == TType.STRUCT:
10642 
          self.cex = CatalogServiceException()
10643 
          self.cex.read(iprot)
10644 
        else:
10645 
          iprot.skip(ftype)
10646 
      else:
10647 
        iprot.skip(ftype)
10648 
      iprot.readFieldEnd()
10649 
    iprot.readStructEnd()
10650 
 
10651 
  def write(self, oprot):
10652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10654 
      return
10655 
    oprot.writeStructBegin('getBestSellersCount_result')
10656 
    if self.success is not None:
10657 
      oprot.writeFieldBegin('success', TType.I64, 0)
10658 
      oprot.writeI64(self.success)
10659 
      oprot.writeFieldEnd()
10660 
    if self.cex is not None:
10661 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10662 
      self.cex.write(oprot)
10663 
      oprot.writeFieldEnd()
10664 
    oprot.writeFieldStop()
10665 
    oprot.writeStructEnd()
10666 
 
10667 
  def validate(self):
10668 
    return
10669 
 
10670 
 
10671 
  def __repr__(self):
10672 
    L = ['%s=%r' % (key, value)
10673 
      for key, value in self.__dict__.iteritems()]
10674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10675 
 
10676 
  def __eq__(self, other):
10677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10678 
 
10679 
  def __ne__(self, other):
10680 
    return not (self == other)
10681 
 
10682 
class getBestDeals_args:
10683 
 
10684 
  thrift_spec = (
10685 
  )
10686 
 
10687 
  def read(self, iprot):
10688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10690 
      return
10691 
    iprot.readStructBegin()
10692 
    while True:
10693 
      (fname, ftype, fid) = iprot.readFieldBegin()
10694 
      if ftype == TType.STOP:
10695 
        break
10696 
      else:
10697 
        iprot.skip(ftype)
10698 
      iprot.readFieldEnd()
10699 
    iprot.readStructEnd()
10700 
 
10701 
  def write(self, oprot):
10702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10704 
      return
10705 
    oprot.writeStructBegin('getBestDeals_args')
10706 
    oprot.writeFieldStop()
10707 
    oprot.writeStructEnd()
10708 
 
10709 
  def validate(self):
10710 
    return
10711 
 
10712 
 
10713 
  def __repr__(self):
10714 
    L = ['%s=%r' % (key, value)
10715 
      for key, value in self.__dict__.iteritems()]
10716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10717 
 
10718 
  def __eq__(self, other):
10719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10720 
 
10721 
  def __ne__(self, other):
10722 
    return not (self == other)
10723 
 
10724 
class getBestDeals_result:
10725 
  """
10726 
  Attributes:
10727 
   - success
10728 
   - isex
10729 
  """
10730 
 
10731 
  thrift_spec = (
10732 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10733 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10734 
  )
10735 
 
10736 
  def __init__(self, success=None, isex=None,):
10737 
    self.success = success
10738 
    self.isex = isex
10739 
 
10740 
  def read(self, iprot):
10741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10743 
      return
10744 
    iprot.readStructBegin()
10745 
    while True:
10746 
      (fname, ftype, fid) = iprot.readFieldBegin()
10747 
      if ftype == TType.STOP:
10748 
        break
10749 
      if fid == 0:
10750 
        if ftype == TType.LIST:
10751 
          self.success = []
8590 kshitij.so 10752 
          (_etype105, _size102) = iprot.readListBegin()
10753 
          for _i106 in xrange(_size102):
10754 
            _elem107 = Item()
10755 
            _elem107.read(iprot)
10756 
            self.success.append(_elem107)
5944 mandeep.dh 10757 
          iprot.readListEnd()
10758 
        else:
10759 
          iprot.skip(ftype)
10760 
      elif fid == 1:
10761 
        if ftype == TType.STRUCT:
10762 
          self.isex = CatalogServiceException()
10763 
          self.isex.read(iprot)
10764 
        else:
10765 
          iprot.skip(ftype)
10766 
      else:
10767 
        iprot.skip(ftype)
10768 
      iprot.readFieldEnd()
10769 
    iprot.readStructEnd()
10770 
 
10771 
  def write(self, oprot):
10772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10774 
      return
10775 
    oprot.writeStructBegin('getBestDeals_result')
10776 
    if self.success is not None:
10777 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10778 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10779 
      for iter108 in self.success:
10780 
        iter108.write(oprot)
5944 mandeep.dh 10781 
      oprot.writeListEnd()
10782 
      oprot.writeFieldEnd()
10783 
    if self.isex is not None:
10784 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10785 
      self.isex.write(oprot)
10786 
      oprot.writeFieldEnd()
10787 
    oprot.writeFieldStop()
10788 
    oprot.writeStructEnd()
10789 
 
10790 
  def validate(self):
10791 
    return
10792 
 
10793 
 
10794 
  def __repr__(self):
10795 
    L = ['%s=%r' % (key, value)
10796 
      for key, value in self.__dict__.iteritems()]
10797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10798 
 
10799 
  def __eq__(self, other):
10800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10801 
 
10802 
  def __ne__(self, other):
10803 
    return not (self == other)
10804 
 
10805 
class getBestDealsCatalogIds_args:
10806 
  """
10807 
  Attributes:
10808 
   - beginIndex
10809 
   - totalItems
10810 
   - brand
10811 
   - category
10812 
  """
10813 
 
10814 
  thrift_spec = (
10815 
    None, # 0
10816 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10817 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10818 
    (3, TType.STRING, 'brand', None, None, ), # 3
10819 
    (4, TType.I64, 'category', None, None, ), # 4
10820 
  )
10821 
 
10822 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10823 
    self.beginIndex = beginIndex
10824 
    self.totalItems = totalItems
10825 
    self.brand = brand
10826 
    self.category = category
10827 
 
10828 
  def read(self, iprot):
10829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10831 
      return
10832 
    iprot.readStructBegin()
10833 
    while True:
10834 
      (fname, ftype, fid) = iprot.readFieldBegin()
10835 
      if ftype == TType.STOP:
10836 
        break
10837 
      if fid == 1:
10838 
        if ftype == TType.I64:
10839 
          self.beginIndex = iprot.readI64();
10840 
        else:
10841 
          iprot.skip(ftype)
10842 
      elif fid == 2:
10843 
        if ftype == TType.I64:
10844 
          self.totalItems = iprot.readI64();
10845 
        else:
10846 
          iprot.skip(ftype)
10847 
      elif fid == 3:
10848 
        if ftype == TType.STRING:
10849 
          self.brand = iprot.readString();
10850 
        else:
10851 
          iprot.skip(ftype)
10852 
      elif fid == 4:
10853 
        if ftype == TType.I64:
10854 
          self.category = iprot.readI64();
10855 
        else:
10856 
          iprot.skip(ftype)
10857 
      else:
10858 
        iprot.skip(ftype)
10859 
      iprot.readFieldEnd()
10860 
    iprot.readStructEnd()
10861 
 
10862 
  def write(self, oprot):
10863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10865 
      return
10866 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
10867 
    if self.beginIndex is not None:
10868 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10869 
      oprot.writeI64(self.beginIndex)
10870 
      oprot.writeFieldEnd()
10871 
    if self.totalItems is not None:
10872 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10873 
      oprot.writeI64(self.totalItems)
10874 
      oprot.writeFieldEnd()
10875 
    if self.brand is not None:
10876 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10877 
      oprot.writeString(self.brand)
10878 
      oprot.writeFieldEnd()
10879 
    if self.category is not None:
10880 
      oprot.writeFieldBegin('category', TType.I64, 4)
10881 
      oprot.writeI64(self.category)
10882 
      oprot.writeFieldEnd()
10883 
    oprot.writeFieldStop()
10884 
    oprot.writeStructEnd()
10885 
 
10886 
  def validate(self):
10887 
    return
10888 
 
10889 
 
10890 
  def __repr__(self):
10891 
    L = ['%s=%r' % (key, value)
10892 
      for key, value in self.__dict__.iteritems()]
10893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10894 
 
10895 
  def __eq__(self, other):
10896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10897 
 
10898 
  def __ne__(self, other):
10899 
    return not (self == other)
10900 
 
10901 
class getBestDealsCatalogIds_result:
10902 
  """
10903 
  Attributes:
10904 
   - success
10905 
   - cex
10906 
  """
10907 
 
10908 
  thrift_spec = (
10909 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10910 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10911 
  )
10912 
 
10913 
  def __init__(self, success=None, cex=None,):
10914 
    self.success = success
10915 
    self.cex = cex
10916 
 
10917 
  def read(self, iprot):
10918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10920 
      return
10921 
    iprot.readStructBegin()
10922 
    while True:
10923 
      (fname, ftype, fid) = iprot.readFieldBegin()
10924 
      if ftype == TType.STOP:
10925 
        break
10926 
      if fid == 0:
10927 
        if ftype == TType.LIST:
10928 
          self.success = []
8590 kshitij.so 10929 
          (_etype112, _size109) = iprot.readListBegin()
10930 
          for _i113 in xrange(_size109):
10931 
            _elem114 = iprot.readI64();
10932 
            self.success.append(_elem114)
5944 mandeep.dh 10933 
          iprot.readListEnd()
10934 
        else:
10935 
          iprot.skip(ftype)
10936 
      elif fid == 1:
10937 
        if ftype == TType.STRUCT:
10938 
          self.cex = CatalogServiceException()
10939 
          self.cex.read(iprot)
10940 
        else:
10941 
          iprot.skip(ftype)
10942 
      else:
10943 
        iprot.skip(ftype)
10944 
      iprot.readFieldEnd()
10945 
    iprot.readStructEnd()
10946 
 
10947 
  def write(self, oprot):
10948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10950 
      return
10951 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
10952 
    if self.success is not None:
10953 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10954 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10955 
      for iter115 in self.success:
10956 
        oprot.writeI64(iter115)
5944 mandeep.dh 10957 
      oprot.writeListEnd()
10958 
      oprot.writeFieldEnd()
10959 
    if self.cex is not None:
10960 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10961 
      self.cex.write(oprot)
10962 
      oprot.writeFieldEnd()
10963 
    oprot.writeFieldStop()
10964 
    oprot.writeStructEnd()
10965 
 
10966 
  def validate(self):
10967 
    return
10968 
 
10969 
 
10970 
  def __repr__(self):
10971 
    L = ['%s=%r' % (key, value)
10972 
      for key, value in self.__dict__.iteritems()]
10973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10974 
 
10975 
  def __eq__(self, other):
10976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10977 
 
10978 
  def __ne__(self, other):
10979 
    return not (self == other)
10980 
 
10981 
class getBestDealsCount_args:
10982 
 
10983 
  thrift_spec = (
10984 
  )
10985 
 
10986 
  def read(self, iprot):
10987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10989 
      return
10990 
    iprot.readStructBegin()
10991 
    while True:
10992 
      (fname, ftype, fid) = iprot.readFieldBegin()
10993 
      if ftype == TType.STOP:
10994 
        break
10995 
      else:
10996 
        iprot.skip(ftype)
10997 
      iprot.readFieldEnd()
10998 
    iprot.readStructEnd()
10999 
 
11000 
  def write(self, oprot):
11001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11003 
      return
11004 
    oprot.writeStructBegin('getBestDealsCount_args')
11005 
    oprot.writeFieldStop()
11006 
    oprot.writeStructEnd()
11007 
 
11008 
  def validate(self):
11009 
    return
11010 
 
11011 
 
11012 
  def __repr__(self):
11013 
    L = ['%s=%r' % (key, value)
11014 
      for key, value in self.__dict__.iteritems()]
11015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11016 
 
11017 
  def __eq__(self, other):
11018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11019 
 
11020 
  def __ne__(self, other):
11021 
    return not (self == other)
11022 
 
11023 
class getBestDealsCount_result:
11024 
  """
11025 
  Attributes:
11026 
   - success
11027 
   - cex
11028 
  """
11029 
 
11030 
  thrift_spec = (
11031 
    (0, TType.I64, 'success', None, None, ), # 0
11032 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11033 
  )
11034 
 
11035 
  def __init__(self, success=None, cex=None,):
11036 
    self.success = success
11037 
    self.cex = cex
11038 
 
11039 
  def read(self, iprot):
11040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11042 
      return
11043 
    iprot.readStructBegin()
11044 
    while True:
11045 
      (fname, ftype, fid) = iprot.readFieldBegin()
11046 
      if ftype == TType.STOP:
11047 
        break
11048 
      if fid == 0:
11049 
        if ftype == TType.I64:
11050 
          self.success = iprot.readI64();
11051 
        else:
11052 
          iprot.skip(ftype)
11053 
      elif fid == 1:
11054 
        if ftype == TType.STRUCT:
11055 
          self.cex = CatalogServiceException()
11056 
          self.cex.read(iprot)
11057 
        else:
11058 
          iprot.skip(ftype)
11059 
      else:
11060 
        iprot.skip(ftype)
11061 
      iprot.readFieldEnd()
11062 
    iprot.readStructEnd()
11063 
 
11064 
  def write(self, oprot):
11065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11067 
      return
11068 
    oprot.writeStructBegin('getBestDealsCount_result')
11069 
    if self.success is not None:
11070 
      oprot.writeFieldBegin('success', TType.I64, 0)
11071 
      oprot.writeI64(self.success)
11072 
      oprot.writeFieldEnd()
11073 
    if self.cex is not None:
11074 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11075 
      self.cex.write(oprot)
11076 
      oprot.writeFieldEnd()
11077 
    oprot.writeFieldStop()
11078 
    oprot.writeStructEnd()
11079 
 
11080 
  def validate(self):
11081 
    return
11082 
 
11083 
 
11084 
  def __repr__(self):
11085 
    L = ['%s=%r' % (key, value)
11086 
      for key, value in self.__dict__.iteritems()]
11087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11088 
 
11089 
  def __eq__(self, other):
11090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11091 
 
11092 
  def __ne__(self, other):
11093 
    return not (self == other)
11094 
 
11095 
class getComingSoon_args:
11096 
 
11097 
  thrift_spec = (
11098 
  )
11099 
 
11100 
  def read(self, iprot):
11101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11103 
      return
11104 
    iprot.readStructBegin()
11105 
    while True:
11106 
      (fname, ftype, fid) = iprot.readFieldBegin()
11107 
      if ftype == TType.STOP:
11108 
        break
11109 
      else:
11110 
        iprot.skip(ftype)
11111 
      iprot.readFieldEnd()
11112 
    iprot.readStructEnd()
11113 
 
11114 
  def write(self, oprot):
11115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11117 
      return
11118 
    oprot.writeStructBegin('getComingSoon_args')
11119 
    oprot.writeFieldStop()
11120 
    oprot.writeStructEnd()
11121 
 
11122 
  def validate(self):
11123 
    return
11124 
 
11125 
 
11126 
  def __repr__(self):
11127 
    L = ['%s=%r' % (key, value)
11128 
      for key, value in self.__dict__.iteritems()]
11129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11130 
 
11131 
  def __eq__(self, other):
11132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11133 
 
11134 
  def __ne__(self, other):
11135 
    return not (self == other)
11136 
 
11137 
class getComingSoon_result:
11138 
  """
11139 
  Attributes:
11140 
   - success
11141 
   - isex
11142 
  """
11143 
 
11144 
  thrift_spec = (
11145 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11146 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11147 
  )
11148 
 
11149 
  def __init__(self, success=None, isex=None,):
11150 
    self.success = success
11151 
    self.isex = isex
11152 
 
11153 
  def read(self, iprot):
11154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11156 
      return
11157 
    iprot.readStructBegin()
11158 
    while True:
11159 
      (fname, ftype, fid) = iprot.readFieldBegin()
11160 
      if ftype == TType.STOP:
11161 
        break
11162 
      if fid == 0:
11163 
        if ftype == TType.LIST:
11164 
          self.success = []
8590 kshitij.so 11165 
          (_etype119, _size116) = iprot.readListBegin()
11166 
          for _i120 in xrange(_size116):
11167 
            _elem121 = Item()
11168 
            _elem121.read(iprot)
11169 
            self.success.append(_elem121)
5944 mandeep.dh 11170 
          iprot.readListEnd()
11171 
        else:
11172 
          iprot.skip(ftype)
11173 
      elif fid == 1:
11174 
        if ftype == TType.STRUCT:
11175 
          self.isex = CatalogServiceException()
11176 
          self.isex.read(iprot)
11177 
        else:
11178 
          iprot.skip(ftype)
11179 
      else:
11180 
        iprot.skip(ftype)
11181 
      iprot.readFieldEnd()
11182 
    iprot.readStructEnd()
11183 
 
11184 
  def write(self, oprot):
11185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11187 
      return
11188 
    oprot.writeStructBegin('getComingSoon_result')
11189 
    if self.success is not None:
11190 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11191 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11192 
      for iter122 in self.success:
11193 
        iter122.write(oprot)
5944 mandeep.dh 11194 
      oprot.writeListEnd()
11195 
      oprot.writeFieldEnd()
11196 
    if self.isex is not None:
11197 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11198 
      self.isex.write(oprot)
11199 
      oprot.writeFieldEnd()
11200 
    oprot.writeFieldStop()
11201 
    oprot.writeStructEnd()
11202 
 
11203 
  def validate(self):
11204 
    return
11205 
 
11206 
 
11207 
  def __repr__(self):
11208 
    L = ['%s=%r' % (key, value)
11209 
      for key, value in self.__dict__.iteritems()]
11210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11211 
 
11212 
  def __eq__(self, other):
11213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11214 
 
11215 
  def __ne__(self, other):
11216 
    return not (self == other)
11217 
 
11218 
class getComingSoonCatalogIds_args:
11219 
  """
11220 
  Attributes:
11221 
   - beginIndex
11222 
   - totalItems
11223 
   - brand
11224 
   - category
11225 
  """
11226 
 
11227 
  thrift_spec = (
11228 
    None, # 0
11229 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11230 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11231 
    (3, TType.STRING, 'brand', None, None, ), # 3
11232 
    (4, TType.I64, 'category', None, None, ), # 4
11233 
  )
11234 
 
11235 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
11236 
    self.beginIndex = beginIndex
11237 
    self.totalItems = totalItems
11238 
    self.brand = brand
11239 
    self.category = category
11240 
 
11241 
  def read(self, iprot):
11242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11244 
      return
11245 
    iprot.readStructBegin()
11246 
    while True:
11247 
      (fname, ftype, fid) = iprot.readFieldBegin()
11248 
      if ftype == TType.STOP:
11249 
        break
11250 
      if fid == 1:
11251 
        if ftype == TType.I64:
11252 
          self.beginIndex = iprot.readI64();
11253 
        else:
11254 
          iprot.skip(ftype)
11255 
      elif fid == 2:
11256 
        if ftype == TType.I64:
11257 
          self.totalItems = iprot.readI64();
11258 
        else:
11259 
          iprot.skip(ftype)
11260 
      elif fid == 3:
11261 
        if ftype == TType.STRING:
11262 
          self.brand = iprot.readString();
11263 
        else:
11264 
          iprot.skip(ftype)
11265 
      elif fid == 4:
11266 
        if ftype == TType.I64:
11267 
          self.category = iprot.readI64();
11268 
        else:
11269 
          iprot.skip(ftype)
11270 
      else:
11271 
        iprot.skip(ftype)
11272 
      iprot.readFieldEnd()
11273 
    iprot.readStructEnd()
11274 
 
11275 
  def write(self, oprot):
11276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11278 
      return
11279 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
11280 
    if self.beginIndex is not None:
11281 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11282 
      oprot.writeI64(self.beginIndex)
11283 
      oprot.writeFieldEnd()
11284 
    if self.totalItems is not None:
11285 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11286 
      oprot.writeI64(self.totalItems)
11287 
      oprot.writeFieldEnd()
11288 
    if self.brand is not None:
11289 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11290 
      oprot.writeString(self.brand)
11291 
      oprot.writeFieldEnd()
11292 
    if self.category is not None:
11293 
      oprot.writeFieldBegin('category', TType.I64, 4)
11294 
      oprot.writeI64(self.category)
11295 
      oprot.writeFieldEnd()
11296 
    oprot.writeFieldStop()
11297 
    oprot.writeStructEnd()
11298 
 
11299 
  def validate(self):
11300 
    return
11301 
 
11302 
 
11303 
  def __repr__(self):
11304 
    L = ['%s=%r' % (key, value)
11305 
      for key, value in self.__dict__.iteritems()]
11306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11307 
 
11308 
  def __eq__(self, other):
11309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11310 
 
11311 
  def __ne__(self, other):
11312 
    return not (self == other)
11313 
 
11314 
class getComingSoonCatalogIds_result:
11315 
  """
11316 
  Attributes:
11317 
   - success
11318 
   - cex
11319 
  """
11320 
 
11321 
  thrift_spec = (
11322 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11323 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11324 
  )
11325 
 
11326 
  def __init__(self, success=None, cex=None,):
11327 
    self.success = success
11328 
    self.cex = cex
11329 
 
11330 
  def read(self, iprot):
11331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11333 
      return
11334 
    iprot.readStructBegin()
11335 
    while True:
11336 
      (fname, ftype, fid) = iprot.readFieldBegin()
11337 
      if ftype == TType.STOP:
11338 
        break
11339 
      if fid == 0:
11340 
        if ftype == TType.LIST:
11341 
          self.success = []
8590 kshitij.so 11342 
          (_etype126, _size123) = iprot.readListBegin()
11343 
          for _i127 in xrange(_size123):
11344 
            _elem128 = iprot.readI64();
11345 
            self.success.append(_elem128)
5944 mandeep.dh 11346 
          iprot.readListEnd()
11347 
        else:
11348 
          iprot.skip(ftype)
11349 
      elif fid == 1:
11350 
        if ftype == TType.STRUCT:
11351 
          self.cex = CatalogServiceException()
11352 
          self.cex.read(iprot)
11353 
        else:
11354 
          iprot.skip(ftype)
11355 
      else:
11356 
        iprot.skip(ftype)
11357 
      iprot.readFieldEnd()
11358 
    iprot.readStructEnd()
11359 
 
11360 
  def write(self, oprot):
11361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11363 
      return
11364 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
11365 
    if self.success is not None:
11366 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11367 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11368 
      for iter129 in self.success:
11369 
        oprot.writeI64(iter129)
5944 mandeep.dh 11370 
      oprot.writeListEnd()
11371 
      oprot.writeFieldEnd()
11372 
    if self.cex is not None:
11373 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11374 
      self.cex.write(oprot)
11375 
      oprot.writeFieldEnd()
11376 
    oprot.writeFieldStop()
11377 
    oprot.writeStructEnd()
11378 
 
11379 
  def validate(self):
11380 
    return
11381 
 
11382 
 
11383 
  def __repr__(self):
11384 
    L = ['%s=%r' % (key, value)
11385 
      for key, value in self.__dict__.iteritems()]
11386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11387 
 
11388 
  def __eq__(self, other):
11389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11390 
 
11391 
  def __ne__(self, other):
11392 
    return not (self == other)
11393 
 
11394 
class getComingSoonCount_args:
11395 
 
11396 
  thrift_spec = (
11397 
  )
11398 
 
11399 
  def read(self, iprot):
11400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11402 
      return
11403 
    iprot.readStructBegin()
11404 
    while True:
11405 
      (fname, ftype, fid) = iprot.readFieldBegin()
11406 
      if ftype == TType.STOP:
11407 
        break
11408 
      else:
11409 
        iprot.skip(ftype)
11410 
      iprot.readFieldEnd()
11411 
    iprot.readStructEnd()
11412 
 
11413 
  def write(self, oprot):
11414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11416 
      return
11417 
    oprot.writeStructBegin('getComingSoonCount_args')
11418 
    oprot.writeFieldStop()
11419 
    oprot.writeStructEnd()
11420 
 
11421 
  def validate(self):
11422 
    return
11423 
 
11424 
 
11425 
  def __repr__(self):
11426 
    L = ['%s=%r' % (key, value)
11427 
      for key, value in self.__dict__.iteritems()]
11428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11429 
 
11430 
  def __eq__(self, other):
11431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11432 
 
11433 
  def __ne__(self, other):
11434 
    return not (self == other)
11435 
 
11436 
class getComingSoonCount_result:
11437 
  """
11438 
  Attributes:
11439 
   - success
11440 
   - cex
11441 
  """
11442 
 
11443 
  thrift_spec = (
11444 
    (0, TType.I64, 'success', None, None, ), # 0
11445 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11446 
  )
11447 
 
11448 
  def __init__(self, success=None, cex=None,):
11449 
    self.success = success
11450 
    self.cex = cex
11451 
 
11452 
  def read(self, iprot):
11453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11455 
      return
11456 
    iprot.readStructBegin()
11457 
    while True:
11458 
      (fname, ftype, fid) = iprot.readFieldBegin()
11459 
      if ftype == TType.STOP:
11460 
        break
11461 
      if fid == 0:
11462 
        if ftype == TType.I64:
11463 
          self.success = iprot.readI64();
11464 
        else:
11465 
          iprot.skip(ftype)
11466 
      elif fid == 1:
11467 
        if ftype == TType.STRUCT:
11468 
          self.cex = CatalogServiceException()
11469 
          self.cex.read(iprot)
11470 
        else:
11471 
          iprot.skip(ftype)
11472 
      else:
11473 
        iprot.skip(ftype)
11474 
      iprot.readFieldEnd()
11475 
    iprot.readStructEnd()
11476 
 
11477 
  def write(self, oprot):
11478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11480 
      return
11481 
    oprot.writeStructBegin('getComingSoonCount_result')
11482 
    if self.success is not None:
11483 
      oprot.writeFieldBegin('success', TType.I64, 0)
11484 
      oprot.writeI64(self.success)
11485 
      oprot.writeFieldEnd()
11486 
    if self.cex is not None:
11487 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11488 
      self.cex.write(oprot)
11489 
      oprot.writeFieldEnd()
11490 
    oprot.writeFieldStop()
11491 
    oprot.writeStructEnd()
11492 
 
11493 
  def validate(self):
11494 
    return
11495 
 
11496 
 
11497 
  def __repr__(self):
11498 
    L = ['%s=%r' % (key, value)
11499 
      for key, value in self.__dict__.iteritems()]
11500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11501 
 
11502 
  def __eq__(self, other):
11503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11504 
 
11505 
  def __ne__(self, other):
11506 
    return not (self == other)
11507 
 
11508 
class getLatestArrivals_args:
11509 
 
11510 
  thrift_spec = (
11511 
  )
11512 
 
11513 
  def read(self, iprot):
11514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11516 
      return
11517 
    iprot.readStructBegin()
11518 
    while True:
11519 
      (fname, ftype, fid) = iprot.readFieldBegin()
11520 
      if ftype == TType.STOP:
11521 
        break
11522 
      else:
11523 
        iprot.skip(ftype)
11524 
      iprot.readFieldEnd()
11525 
    iprot.readStructEnd()
11526 
 
11527 
  def write(self, oprot):
11528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11530 
      return
11531 
    oprot.writeStructBegin('getLatestArrivals_args')
11532 
    oprot.writeFieldStop()
11533 
    oprot.writeStructEnd()
11534 
 
11535 
  def validate(self):
11536 
    return
11537 
 
11538 
 
11539 
  def __repr__(self):
11540 
    L = ['%s=%r' % (key, value)
11541 
      for key, value in self.__dict__.iteritems()]
11542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11543 
 
11544 
  def __eq__(self, other):
11545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11546 
 
11547 
  def __ne__(self, other):
11548 
    return not (self == other)
11549 
 
11550 
class getLatestArrivals_result:
11551 
  """
11552 
  Attributes:
11553 
   - success
11554 
   - isex
11555 
  """
11556 
 
11557 
  thrift_spec = (
11558 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11559 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11560 
  )
11561 
 
11562 
  def __init__(self, success=None, isex=None,):
11563 
    self.success = success
11564 
    self.isex = isex
11565 
 
11566 
  def read(self, iprot):
11567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11569 
      return
11570 
    iprot.readStructBegin()
11571 
    while True:
11572 
      (fname, ftype, fid) = iprot.readFieldBegin()
11573 
      if ftype == TType.STOP:
11574 
        break
11575 
      if fid == 0:
11576 
        if ftype == TType.LIST:
11577 
          self.success = []
8590 kshitij.so 11578 
          (_etype133, _size130) = iprot.readListBegin()
11579 
          for _i134 in xrange(_size130):
11580 
            _elem135 = Item()
11581 
            _elem135.read(iprot)
11582 
            self.success.append(_elem135)
5944 mandeep.dh 11583 
          iprot.readListEnd()
11584 
        else:
11585 
          iprot.skip(ftype)
11586 
      elif fid == 1:
11587 
        if ftype == TType.STRUCT:
11588 
          self.isex = CatalogServiceException()
11589 
          self.isex.read(iprot)
11590 
        else:
11591 
          iprot.skip(ftype)
11592 
      else:
11593 
        iprot.skip(ftype)
11594 
      iprot.readFieldEnd()
11595 
    iprot.readStructEnd()
11596 
 
11597 
  def write(self, oprot):
11598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11600 
      return
11601 
    oprot.writeStructBegin('getLatestArrivals_result')
11602 
    if self.success is not None:
11603 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11604 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11605 
      for iter136 in self.success:
11606 
        iter136.write(oprot)
5944 mandeep.dh 11607 
      oprot.writeListEnd()
11608 
      oprot.writeFieldEnd()
11609 
    if self.isex is not None:
11610 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11611 
      self.isex.write(oprot)
11612 
      oprot.writeFieldEnd()
11613 
    oprot.writeFieldStop()
11614 
    oprot.writeStructEnd()
11615 
 
11616 
  def validate(self):
11617 
    return
11618 
 
11619 
 
11620 
  def __repr__(self):
11621 
    L = ['%s=%r' % (key, value)
11622 
      for key, value in self.__dict__.iteritems()]
11623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11624 
 
11625 
  def __eq__(self, other):
11626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11627 
 
11628 
  def __ne__(self, other):
11629 
    return not (self == other)
11630 
 
11631 
class getLatestArrivalsCatalogIds_args:
11632 
  """
11633 
  Attributes:
11634 
   - beginIndex
11635 
   - totalItems
11636 
   - brand
11637 
   - categories
11638 
  """
11639 
 
11640 
  thrift_spec = (
11641 
    None, # 0
11642 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11643 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11644 
    (3, TType.STRING, 'brand', None, None, ), # 3
11645 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
11646 
  )
11647 
 
11648 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
11649 
    self.beginIndex = beginIndex
11650 
    self.totalItems = totalItems
11651 
    self.brand = brand
11652 
    self.categories = categories
11653 
 
11654 
  def read(self, iprot):
11655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11657 
      return
11658 
    iprot.readStructBegin()
11659 
    while True:
11660 
      (fname, ftype, fid) = iprot.readFieldBegin()
11661 
      if ftype == TType.STOP:
11662 
        break
11663 
      if fid == 1:
11664 
        if ftype == TType.I64:
11665 
          self.beginIndex = iprot.readI64();
11666 
        else:
11667 
          iprot.skip(ftype)
11668 
      elif fid == 2:
11669 
        if ftype == TType.I64:
11670 
          self.totalItems = iprot.readI64();
11671 
        else:
11672 
          iprot.skip(ftype)
11673 
      elif fid == 3:
11674 
        if ftype == TType.STRING:
11675 
          self.brand = iprot.readString();
11676 
        else:
11677 
          iprot.skip(ftype)
11678 
      elif fid == 4:
11679 
        if ftype == TType.LIST:
11680 
          self.categories = []
8590 kshitij.so 11681 
          (_etype140, _size137) = iprot.readListBegin()
11682 
          for _i141 in xrange(_size137):
11683 
            _elem142 = iprot.readI64();
11684 
            self.categories.append(_elem142)
5944 mandeep.dh 11685 
          iprot.readListEnd()
11686 
        else:
11687 
          iprot.skip(ftype)
11688 
      else:
11689 
        iprot.skip(ftype)
11690 
      iprot.readFieldEnd()
11691 
    iprot.readStructEnd()
11692 
 
11693 
  def write(self, oprot):
11694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11696 
      return
11697 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
11698 
    if self.beginIndex is not None:
11699 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11700 
      oprot.writeI64(self.beginIndex)
11701 
      oprot.writeFieldEnd()
11702 
    if self.totalItems is not None:
11703 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11704 
      oprot.writeI64(self.totalItems)
11705 
      oprot.writeFieldEnd()
11706 
    if self.brand is not None:
11707 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11708 
      oprot.writeString(self.brand)
11709 
      oprot.writeFieldEnd()
11710 
    if self.categories is not None:
11711 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
11712 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 11713 
      for iter143 in self.categories:
11714 
        oprot.writeI64(iter143)
5944 mandeep.dh 11715 
      oprot.writeListEnd()
11716 
      oprot.writeFieldEnd()
11717 
    oprot.writeFieldStop()
11718 
    oprot.writeStructEnd()
11719 
 
11720 
  def validate(self):
11721 
    return
11722 
 
11723 
 
11724 
  def __repr__(self):
11725 
    L = ['%s=%r' % (key, value)
11726 
      for key, value in self.__dict__.iteritems()]
11727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11728 
 
11729 
  def __eq__(self, other):
11730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11731 
 
11732 
  def __ne__(self, other):
11733 
    return not (self == other)
11734 
 
11735 
class getLatestArrivalsCatalogIds_result:
11736 
  """
11737 
  Attributes:
11738 
   - success
11739 
   - cex
11740 
  """
11741 
 
11742 
  thrift_spec = (
11743 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11744 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11745 
  )
11746 
 
11747 
  def __init__(self, success=None, cex=None,):
11748 
    self.success = success
11749 
    self.cex = cex
11750 
 
11751 
  def read(self, iprot):
11752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11754 
      return
11755 
    iprot.readStructBegin()
11756 
    while True:
11757 
      (fname, ftype, fid) = iprot.readFieldBegin()
11758 
      if ftype == TType.STOP:
11759 
        break
11760 
      if fid == 0:
11761 
        if ftype == TType.LIST:
11762 
          self.success = []
8590 kshitij.so 11763 
          (_etype147, _size144) = iprot.readListBegin()
11764 
          for _i148 in xrange(_size144):
11765 
            _elem149 = iprot.readI64();
11766 
            self.success.append(_elem149)
5944 mandeep.dh 11767 
          iprot.readListEnd()
11768 
        else:
11769 
          iprot.skip(ftype)
11770 
      elif fid == 1:
11771 
        if ftype == TType.STRUCT:
11772 
          self.cex = CatalogServiceException()
11773 
          self.cex.read(iprot)
11774 
        else:
11775 
          iprot.skip(ftype)
11776 
      else:
11777 
        iprot.skip(ftype)
11778 
      iprot.readFieldEnd()
11779 
    iprot.readStructEnd()
11780 
 
11781 
  def write(self, oprot):
11782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11784 
      return
11785 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
11786 
    if self.success is not None:
11787 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11788 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11789 
      for iter150 in self.success:
11790 
        oprot.writeI64(iter150)
5944 mandeep.dh 11791 
      oprot.writeListEnd()
11792 
      oprot.writeFieldEnd()
11793 
    if self.cex is not None:
11794 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11795 
      self.cex.write(oprot)
11796 
      oprot.writeFieldEnd()
11797 
    oprot.writeFieldStop()
11798 
    oprot.writeStructEnd()
11799 
 
11800 
  def validate(self):
11801 
    return
11802 
 
11803 
 
11804 
  def __repr__(self):
11805 
    L = ['%s=%r' % (key, value)
11806 
      for key, value in self.__dict__.iteritems()]
11807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11808 
 
11809 
  def __eq__(self, other):
11810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11811 
 
11812 
  def __ne__(self, other):
11813 
    return not (self == other)
11814 
 
11815 
class getLatestArrivalsCount_args:
11816 
 
11817 
  thrift_spec = (
11818 
  )
11819 
 
11820 
  def read(self, iprot):
11821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11823 
      return
11824 
    iprot.readStructBegin()
11825 
    while True:
11826 
      (fname, ftype, fid) = iprot.readFieldBegin()
11827 
      if ftype == TType.STOP:
11828 
        break
11829 
      else:
11830 
        iprot.skip(ftype)
11831 
      iprot.readFieldEnd()
11832 
    iprot.readStructEnd()
11833 
 
11834 
  def write(self, oprot):
11835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11837 
      return
11838 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
11839 
    oprot.writeFieldStop()
11840 
    oprot.writeStructEnd()
11841 
 
11842 
  def validate(self):
11843 
    return
11844 
 
11845 
 
11846 
  def __repr__(self):
11847 
    L = ['%s=%r' % (key, value)
11848 
      for key, value in self.__dict__.iteritems()]
11849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11850 
 
11851 
  def __eq__(self, other):
11852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11853 
 
11854 
  def __ne__(self, other):
11855 
    return not (self == other)
11856 
 
11857 
class getLatestArrivalsCount_result:
11858 
  """
11859 
  Attributes:
11860 
   - success
11861 
   - cex
11862 
  """
11863 
 
11864 
  thrift_spec = (
11865 
    (0, TType.I64, 'success', None, None, ), # 0
11866 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11867 
  )
11868 
 
11869 
  def __init__(self, success=None, cex=None,):
11870 
    self.success = success
11871 
    self.cex = cex
11872 
 
11873 
  def read(self, iprot):
11874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11876 
      return
11877 
    iprot.readStructBegin()
11878 
    while True:
11879 
      (fname, ftype, fid) = iprot.readFieldBegin()
11880 
      if ftype == TType.STOP:
11881 
        break
11882 
      if fid == 0:
11883 
        if ftype == TType.I64:
11884 
          self.success = iprot.readI64();
11885 
        else:
11886 
          iprot.skip(ftype)
11887 
      elif fid == 1:
11888 
        if ftype == TType.STRUCT:
11889 
          self.cex = CatalogServiceException()
11890 
          self.cex.read(iprot)
11891 
        else:
11892 
          iprot.skip(ftype)
11893 
      else:
11894 
        iprot.skip(ftype)
11895 
      iprot.readFieldEnd()
11896 
    iprot.readStructEnd()
11897 
 
11898 
  def write(self, oprot):
11899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11901 
      return
11902 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
11903 
    if self.success is not None:
11904 
      oprot.writeFieldBegin('success', TType.I64, 0)
11905 
      oprot.writeI64(self.success)
11906 
      oprot.writeFieldEnd()
11907 
    if self.cex is not None:
11908 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11909 
      self.cex.write(oprot)
11910 
      oprot.writeFieldEnd()
11911 
    oprot.writeFieldStop()
11912 
    oprot.writeStructEnd()
11913 
 
11914 
  def validate(self):
11915 
    return
11916 
 
11917 
 
11918 
  def __repr__(self):
11919 
    L = ['%s=%r' % (key, value)
11920 
      for key, value in self.__dict__.iteritems()]
11921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11922 
 
11923 
  def __eq__(self, other):
11924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11925 
 
11926 
  def __ne__(self, other):
11927 
    return not (self == other)
11928 
 
11929 
class generateNewEntityID_args:
11930 
 
11931 
  thrift_spec = (
11932 
  )
11933 
 
11934 
  def read(self, iprot):
11935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11937 
      return
11938 
    iprot.readStructBegin()
11939 
    while True:
11940 
      (fname, ftype, fid) = iprot.readFieldBegin()
11941 
      if ftype == TType.STOP:
11942 
        break
11943 
      else:
11944 
        iprot.skip(ftype)
11945 
      iprot.readFieldEnd()
11946 
    iprot.readStructEnd()
11947 
 
11948 
  def write(self, oprot):
11949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11951 
      return
11952 
    oprot.writeStructBegin('generateNewEntityID_args')
11953 
    oprot.writeFieldStop()
11954 
    oprot.writeStructEnd()
11955 
 
11956 
  def validate(self):
11957 
    return
11958 
 
11959 
 
11960 
  def __repr__(self):
11961 
    L = ['%s=%r' % (key, value)
11962 
      for key, value in self.__dict__.iteritems()]
11963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11964 
 
11965 
  def __eq__(self, other):
11966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11967 
 
11968 
  def __ne__(self, other):
11969 
    return not (self == other)
11970 
 
11971 
class generateNewEntityID_result:
11972 
  """
11973 
  Attributes:
11974 
   - success
11975 
  """
11976 
 
11977 
  thrift_spec = (
11978 
    (0, TType.I64, 'success', None, None, ), # 0
11979 
  )
11980 
 
11981 
  def __init__(self, success=None,):
11982 
    self.success = success
11983 
 
11984 
  def read(self, iprot):
11985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11987 
      return
11988 
    iprot.readStructBegin()
11989 
    while True:
11990 
      (fname, ftype, fid) = iprot.readFieldBegin()
11991 
      if ftype == TType.STOP:
11992 
        break
11993 
      if fid == 0:
11994 
        if ftype == TType.I64:
11995 
          self.success = iprot.readI64();
11996 
        else:
11997 
          iprot.skip(ftype)
11998 
      else:
11999 
        iprot.skip(ftype)
12000 
      iprot.readFieldEnd()
12001 
    iprot.readStructEnd()
12002 
 
12003 
  def write(self, oprot):
12004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12006 
      return
12007 
    oprot.writeStructBegin('generateNewEntityID_result')
12008 
    if self.success is not None:
12009 
      oprot.writeFieldBegin('success', TType.I64, 0)
12010 
      oprot.writeI64(self.success)
12011 
      oprot.writeFieldEnd()
12012 
    oprot.writeFieldStop()
12013 
    oprot.writeStructEnd()
12014 
 
12015 
  def validate(self):
12016 
    return
12017 
 
12018 
 
12019 
  def __repr__(self):
12020 
    L = ['%s=%r' % (key, value)
12021 
      for key, value in self.__dict__.iteritems()]
12022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12023 
 
12024 
  def __eq__(self, other):
12025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12026 
 
12027 
  def __ne__(self, other):
12028 
    return not (self == other)
12029 
 
12030 
class addCategory_args:
12031 
  """
12032 
  Attributes:
12033 
   - category
12034 
  """
12035 
 
12036 
  thrift_spec = (
12037 
    None, # 0
12038 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
12039 
  )
12040 
 
12041 
  def __init__(self, category=None,):
12042 
    self.category = category
12043 
 
12044 
  def read(self, iprot):
12045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12047 
      return
12048 
    iprot.readStructBegin()
12049 
    while True:
12050 
      (fname, ftype, fid) = iprot.readFieldBegin()
12051 
      if ftype == TType.STOP:
12052 
        break
12053 
      if fid == 1:
12054 
        if ftype == TType.STRUCT:
12055 
          self.category = Category()
12056 
          self.category.read(iprot)
12057 
        else:
12058 
          iprot.skip(ftype)
12059 
      else:
12060 
        iprot.skip(ftype)
12061 
      iprot.readFieldEnd()
12062 
    iprot.readStructEnd()
12063 
 
12064 
  def write(self, oprot):
12065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12067 
      return
12068 
    oprot.writeStructBegin('addCategory_args')
12069 
    if self.category is not None:
12070 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
12071 
      self.category.write(oprot)
12072 
      oprot.writeFieldEnd()
12073 
    oprot.writeFieldStop()
12074 
    oprot.writeStructEnd()
12075 
 
12076 
  def validate(self):
12077 
    return
12078 
 
12079 
 
12080 
  def __repr__(self):
12081 
    L = ['%s=%r' % (key, value)
12082 
      for key, value in self.__dict__.iteritems()]
12083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12084 
 
12085 
  def __eq__(self, other):
12086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12087 
 
12088 
  def __ne__(self, other):
12089 
    return not (self == other)
12090 
 
12091 
class addCategory_result:
12092 
  """
12093 
  Attributes:
12094 
   - success
12095 
  """
12096 
 
12097 
  thrift_spec = (
12098 
    (0, TType.BOOL, 'success', None, None, ), # 0
12099 
  )
12100 
 
12101 
  def __init__(self, success=None,):
12102 
    self.success = success
12103 
 
12104 
  def read(self, iprot):
12105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12107 
      return
12108 
    iprot.readStructBegin()
12109 
    while True:
12110 
      (fname, ftype, fid) = iprot.readFieldBegin()
12111 
      if ftype == TType.STOP:
12112 
        break
12113 
      if fid == 0:
12114 
        if ftype == TType.BOOL:
12115 
          self.success = iprot.readBool();
12116 
        else:
12117 
          iprot.skip(ftype)
12118 
      else:
12119 
        iprot.skip(ftype)
12120 
      iprot.readFieldEnd()
12121 
    iprot.readStructEnd()
12122 
 
12123 
  def write(self, oprot):
12124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12126 
      return
12127 
    oprot.writeStructBegin('addCategory_result')
12128 
    if self.success is not None:
12129 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12130 
      oprot.writeBool(self.success)
12131 
      oprot.writeFieldEnd()
12132 
    oprot.writeFieldStop()
12133 
    oprot.writeStructEnd()
12134 
 
12135 
  def validate(self):
12136 
    return
12137 
 
12138 
 
12139 
  def __repr__(self):
12140 
    L = ['%s=%r' % (key, value)
12141 
      for key, value in self.__dict__.iteritems()]
12142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12143 
 
12144 
  def __eq__(self, other):
12145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12146 
 
12147 
  def __ne__(self, other):
12148 
    return not (self == other)
12149 
 
12150 
class getCategory_args:
12151 
  """
12152 
  Attributes:
12153 
   - id
12154 
  """
12155 
 
12156 
  thrift_spec = (
12157 
    None, # 0
12158 
    (1, TType.I64, 'id', None, None, ), # 1
12159 
  )
12160 
 
12161 
  def __init__(self, id=None,):
12162 
    self.id = id
12163 
 
12164 
  def read(self, iprot):
12165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12167 
      return
12168 
    iprot.readStructBegin()
12169 
    while True:
12170 
      (fname, ftype, fid) = iprot.readFieldBegin()
12171 
      if ftype == TType.STOP:
12172 
        break
12173 
      if fid == 1:
12174 
        if ftype == TType.I64:
12175 
          self.id = iprot.readI64();
12176 
        else:
12177 
          iprot.skip(ftype)
12178 
      else:
12179 
        iprot.skip(ftype)
12180 
      iprot.readFieldEnd()
12181 
    iprot.readStructEnd()
12182 
 
12183 
  def write(self, oprot):
12184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12186 
      return
12187 
    oprot.writeStructBegin('getCategory_args')
12188 
    if self.id is not None:
12189 
      oprot.writeFieldBegin('id', TType.I64, 1)
12190 
      oprot.writeI64(self.id)
12191 
      oprot.writeFieldEnd()
12192 
    oprot.writeFieldStop()
12193 
    oprot.writeStructEnd()
12194 
 
12195 
  def validate(self):
12196 
    return
12197 
 
12198 
 
12199 
  def __repr__(self):
12200 
    L = ['%s=%r' % (key, value)
12201 
      for key, value in self.__dict__.iteritems()]
12202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12203 
 
12204 
  def __eq__(self, other):
12205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12206 
 
12207 
  def __ne__(self, other):
12208 
    return not (self == other)
12209 
 
12210 
class getCategory_result:
12211 
  """
12212 
  Attributes:
12213 
   - success
12214 
  """
12215 
 
12216 
  thrift_spec = (
12217 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
12218 
  )
12219 
 
12220 
  def __init__(self, success=None,):
12221 
    self.success = success
12222 
 
12223 
  def read(self, iprot):
12224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12226 
      return
12227 
    iprot.readStructBegin()
12228 
    while True:
12229 
      (fname, ftype, fid) = iprot.readFieldBegin()
12230 
      if ftype == TType.STOP:
12231 
        break
12232 
      if fid == 0:
12233 
        if ftype == TType.STRUCT:
12234 
          self.success = Category()
12235 
          self.success.read(iprot)
12236 
        else:
12237 
          iprot.skip(ftype)
12238 
      else:
12239 
        iprot.skip(ftype)
12240 
      iprot.readFieldEnd()
12241 
    iprot.readStructEnd()
12242 
 
12243 
  def write(self, oprot):
12244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12246 
      return
12247 
    oprot.writeStructBegin('getCategory_result')
12248 
    if self.success is not None:
12249 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12250 
      self.success.write(oprot)
12251 
      oprot.writeFieldEnd()
12252 
    oprot.writeFieldStop()
12253 
    oprot.writeStructEnd()
12254 
 
12255 
  def validate(self):
12256 
    return
12257 
 
12258 
 
12259 
  def __repr__(self):
12260 
    L = ['%s=%r' % (key, value)
12261 
      for key, value in self.__dict__.iteritems()]
12262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12263 
 
12264 
  def __eq__(self, other):
12265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12266 
 
12267 
  def __ne__(self, other):
12268 
    return not (self == other)
12269 
 
12270 
class getAllCategories_args:
12271 
 
12272 
  thrift_spec = (
12273 
  )
12274 
 
12275 
  def read(self, iprot):
12276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12278 
      return
12279 
    iprot.readStructBegin()
12280 
    while True:
12281 
      (fname, ftype, fid) = iprot.readFieldBegin()
12282 
      if ftype == TType.STOP:
12283 
        break
12284 
      else:
12285 
        iprot.skip(ftype)
12286 
      iprot.readFieldEnd()
12287 
    iprot.readStructEnd()
12288 
 
12289 
  def write(self, oprot):
12290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12292 
      return
12293 
    oprot.writeStructBegin('getAllCategories_args')
12294 
    oprot.writeFieldStop()
12295 
    oprot.writeStructEnd()
12296 
 
12297 
  def validate(self):
12298 
    return
12299 
 
12300 
 
12301 
  def __repr__(self):
12302 
    L = ['%s=%r' % (key, value)
12303 
      for key, value in self.__dict__.iteritems()]
12304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12305 
 
12306 
  def __eq__(self, other):
12307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12308 
 
12309 
  def __ne__(self, other):
12310 
    return not (self == other)
12311 
 
12312 
class getAllCategories_result:
12313 
  """
12314 
  Attributes:
12315 
   - success
12316 
  """
12317 
 
12318 
  thrift_spec = (
12319 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
12320 
  )
12321 
 
12322 
  def __init__(self, success=None,):
12323 
    self.success = success
12324 
 
12325 
  def read(self, iprot):
12326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12328 
      return
12329 
    iprot.readStructBegin()
12330 
    while True:
12331 
      (fname, ftype, fid) = iprot.readFieldBegin()
12332 
      if ftype == TType.STOP:
12333 
        break
12334 
      if fid == 0:
12335 
        if ftype == TType.LIST:
12336 
          self.success = []
8590 kshitij.so 12337 
          (_etype154, _size151) = iprot.readListBegin()
12338 
          for _i155 in xrange(_size151):
12339 
            _elem156 = Category()
12340 
            _elem156.read(iprot)
12341 
            self.success.append(_elem156)
5944 mandeep.dh 12342 
          iprot.readListEnd()
12343 
        else:
12344 
          iprot.skip(ftype)
12345 
      else:
12346 
        iprot.skip(ftype)
12347 
      iprot.readFieldEnd()
12348 
    iprot.readStructEnd()
12349 
 
12350 
  def write(self, oprot):
12351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12353 
      return
12354 
    oprot.writeStructBegin('getAllCategories_result')
12355 
    if self.success is not None:
12356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12357 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12358 
      for iter157 in self.success:
12359 
        iter157.write(oprot)
5944 mandeep.dh 12360 
      oprot.writeListEnd()
12361 
      oprot.writeFieldEnd()
12362 
    oprot.writeFieldStop()
12363 
    oprot.writeStructEnd()
12364 
 
12365 
  def validate(self):
12366 
    return
12367 
 
12368 
 
12369 
  def __repr__(self):
12370 
    L = ['%s=%r' % (key, value)
12371 
      for key, value in self.__dict__.iteritems()]
12372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12373 
 
12374 
  def __eq__(self, other):
12375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12376 
 
12377 
  def __ne__(self, other):
12378 
    return not (self == other)
12379 
 
12380 
class getAllSimilarItems_args:
12381 
  """
12382 
  Attributes:
12383 
   - itemId
12384 
  """
12385 
 
12386 
  thrift_spec = (
12387 
    None, # 0
12388 
    (1, TType.I64, 'itemId', None, None, ), # 1
12389 
  )
12390 
 
12391 
  def __init__(self, itemId=None,):
12392 
    self.itemId = itemId
12393 
 
12394 
  def read(self, iprot):
12395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12397 
      return
12398 
    iprot.readStructBegin()
12399 
    while True:
12400 
      (fname, ftype, fid) = iprot.readFieldBegin()
12401 
      if ftype == TType.STOP:
12402 
        break
12403 
      if fid == 1:
12404 
        if ftype == TType.I64:
12405 
          self.itemId = iprot.readI64();
12406 
        else:
12407 
          iprot.skip(ftype)
12408 
      else:
12409 
        iprot.skip(ftype)
12410 
      iprot.readFieldEnd()
12411 
    iprot.readStructEnd()
12412 
 
12413 
  def write(self, oprot):
12414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12416 
      return
12417 
    oprot.writeStructBegin('getAllSimilarItems_args')
12418 
    if self.itemId is not None:
12419 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12420 
      oprot.writeI64(self.itemId)
12421 
      oprot.writeFieldEnd()
12422 
    oprot.writeFieldStop()
12423 
    oprot.writeStructEnd()
12424 
 
12425 
  def validate(self):
12426 
    return
12427 
 
12428 
 
12429 
  def __repr__(self):
12430 
    L = ['%s=%r' % (key, value)
12431 
      for key, value in self.__dict__.iteritems()]
12432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12433 
 
12434 
  def __eq__(self, other):
12435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12436 
 
12437 
  def __ne__(self, other):
12438 
    return not (self == other)
12439 
 
12440 
class getAllSimilarItems_result:
12441 
  """
12442 
  Attributes:
12443 
   - success
12444 
  """
12445 
 
12446 
  thrift_spec = (
12447 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12448 
  )
12449 
 
12450 
  def __init__(self, success=None,):
12451 
    self.success = success
12452 
 
12453 
  def read(self, iprot):
12454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12456 
      return
12457 
    iprot.readStructBegin()
12458 
    while True:
12459 
      (fname, ftype, fid) = iprot.readFieldBegin()
12460 
      if ftype == TType.STOP:
12461 
        break
12462 
      if fid == 0:
12463 
        if ftype == TType.LIST:
12464 
          self.success = []
8590 kshitij.so 12465 
          (_etype161, _size158) = iprot.readListBegin()
12466 
          for _i162 in xrange(_size158):
12467 
            _elem163 = Item()
12468 
            _elem163.read(iprot)
12469 
            self.success.append(_elem163)
5944 mandeep.dh 12470 
          iprot.readListEnd()
12471 
        else:
12472 
          iprot.skip(ftype)
12473 
      else:
12474 
        iprot.skip(ftype)
12475 
      iprot.readFieldEnd()
12476 
    iprot.readStructEnd()
12477 
 
12478 
  def write(self, oprot):
12479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12481 
      return
12482 
    oprot.writeStructBegin('getAllSimilarItems_result')
12483 
    if self.success is not None:
12484 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12485 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12486 
      for iter164 in self.success:
12487 
        iter164.write(oprot)
5944 mandeep.dh 12488 
      oprot.writeListEnd()
12489 
      oprot.writeFieldEnd()
12490 
    oprot.writeFieldStop()
12491 
    oprot.writeStructEnd()
12492 
 
12493 
  def validate(self):
12494 
    return
12495 
 
12496 
 
12497 
  def __repr__(self):
12498 
    L = ['%s=%r' % (key, value)
12499 
      for key, value in self.__dict__.iteritems()]
12500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12501 
 
12502 
  def __eq__(self, other):
12503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12504 
 
12505 
  def __ne__(self, other):
12506 
    return not (self == other)
12507 
 
12508 
class addSimilarItem_args:
12509 
  """
12510 
  Attributes:
12511 
   - itemId
12512 
   - catalogItemId
12513 
  """
12514 
 
12515 
  thrift_spec = (
12516 
    None, # 0
12517 
    (1, TType.I64, 'itemId', None, None, ), # 1
12518 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
12519 
  )
12520 
 
12521 
  def __init__(self, itemId=None, catalogItemId=None,):
12522 
    self.itemId = itemId
12523 
    self.catalogItemId = catalogItemId
12524 
 
12525 
  def read(self, iprot):
12526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12528 
      return
12529 
    iprot.readStructBegin()
12530 
    while True:
12531 
      (fname, ftype, fid) = iprot.readFieldBegin()
12532 
      if ftype == TType.STOP:
12533 
        break
12534 
      if fid == 1:
12535 
        if ftype == TType.I64:
12536 
          self.itemId = iprot.readI64();
12537 
        else:
12538 
          iprot.skip(ftype)
12539 
      elif fid == 2:
12540 
        if ftype == TType.I64:
12541 
          self.catalogItemId = iprot.readI64();
12542 
        else:
12543 
          iprot.skip(ftype)
12544 
      else:
12545 
        iprot.skip(ftype)
12546 
      iprot.readFieldEnd()
12547 
    iprot.readStructEnd()
12548 
 
12549 
  def write(self, oprot):
12550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12552 
      return
12553 
    oprot.writeStructBegin('addSimilarItem_args')
12554 
    if self.itemId is not None:
12555 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12556 
      oprot.writeI64(self.itemId)
12557 
      oprot.writeFieldEnd()
12558 
    if self.catalogItemId is not None:
12559 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
12560 
      oprot.writeI64(self.catalogItemId)
12561 
      oprot.writeFieldEnd()
12562 
    oprot.writeFieldStop()
12563 
    oprot.writeStructEnd()
12564 
 
12565 
  def validate(self):
12566 
    return
12567 
 
12568 
 
12569 
  def __repr__(self):
12570 
    L = ['%s=%r' % (key, value)
12571 
      for key, value in self.__dict__.iteritems()]
12572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12573 
 
12574 
  def __eq__(self, other):
12575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12576 
 
12577 
  def __ne__(self, other):
12578 
    return not (self == other)
12579 
 
12580 
class addSimilarItem_result:
12581 
  """
12582 
  Attributes:
12583 
   - success
12584 
   - cex
12585 
  """
12586 
 
12587 
  thrift_spec = (
12588 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
12589 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12590 
  )
12591 
 
12592 
  def __init__(self, success=None, cex=None,):
12593 
    self.success = success
12594 
    self.cex = cex
12595 
 
12596 
  def read(self, iprot):
12597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12599 
      return
12600 
    iprot.readStructBegin()
12601 
    while True:
12602 
      (fname, ftype, fid) = iprot.readFieldBegin()
12603 
      if ftype == TType.STOP:
12604 
        break
12605 
      if fid == 0:
12606 
        if ftype == TType.STRUCT:
12607 
          self.success = Item()
12608 
          self.success.read(iprot)
12609 
        else:
12610 
          iprot.skip(ftype)
12611 
      elif fid == 1:
12612 
        if ftype == TType.STRUCT:
12613 
          self.cex = CatalogServiceException()
12614 
          self.cex.read(iprot)
12615 
        else:
12616 
          iprot.skip(ftype)
12617 
      else:
12618 
        iprot.skip(ftype)
12619 
      iprot.readFieldEnd()
12620 
    iprot.readStructEnd()
12621 
 
12622 
  def write(self, oprot):
12623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12625 
      return
12626 
    oprot.writeStructBegin('addSimilarItem_result')
12627 
    if self.success is not None:
12628 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12629 
      self.success.write(oprot)
12630 
      oprot.writeFieldEnd()
12631 
    if self.cex is not None:
12632 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12633 
      self.cex.write(oprot)
12634 
      oprot.writeFieldEnd()
12635 
    oprot.writeFieldStop()
12636 
    oprot.writeStructEnd()
12637 
 
12638 
  def validate(self):
12639 
    return
12640 
 
12641 
 
12642 
  def __repr__(self):
12643 
    L = ['%s=%r' % (key, value)
12644 
      for key, value in self.__dict__.iteritems()]
12645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12646 
 
12647 
  def __eq__(self, other):
12648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12649 
 
12650 
  def __ne__(self, other):
12651 
    return not (self == other)
12652 
 
6512 kshitij.so 12653 
class addTag_args:
12654 
  """
12655 
  Attributes:
12656 
   - displayName
12657 
   - itemId
12658 
  """
12659 
 
12660 
  thrift_spec = (
12661 
    None, # 0
12662 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12663 
    (2, TType.I64, 'itemId', None, None, ), # 2
12664 
  )
12665 
 
12666 
  def __init__(self, displayName=None, itemId=None,):
12667 
    self.displayName = displayName
12668 
    self.itemId = itemId
12669 
 
12670 
  def read(self, iprot):
12671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12673 
      return
12674 
    iprot.readStructBegin()
12675 
    while True:
12676 
      (fname, ftype, fid) = iprot.readFieldBegin()
12677 
      if ftype == TType.STOP:
12678 
        break
12679 
      if fid == 1:
12680 
        if ftype == TType.STRING:
12681 
          self.displayName = iprot.readString();
12682 
        else:
12683 
          iprot.skip(ftype)
12684 
      elif fid == 2:
12685 
        if ftype == TType.I64:
12686 
          self.itemId = iprot.readI64();
12687 
        else:
12688 
          iprot.skip(ftype)
12689 
      else:
12690 
        iprot.skip(ftype)
12691 
      iprot.readFieldEnd()
12692 
    iprot.readStructEnd()
12693 
 
12694 
  def write(self, oprot):
12695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12697 
      return
12698 
    oprot.writeStructBegin('addTag_args')
12699 
    if self.displayName is not None:
12700 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12701 
      oprot.writeString(self.displayName)
12702 
      oprot.writeFieldEnd()
12703 
    if self.itemId is not None:
12704 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12705 
      oprot.writeI64(self.itemId)
12706 
      oprot.writeFieldEnd()
12707 
    oprot.writeFieldStop()
12708 
    oprot.writeStructEnd()
12709 
 
12710 
  def validate(self):
12711 
    return
12712 
 
12713 
 
12714 
  def __repr__(self):
12715 
    L = ['%s=%r' % (key, value)
12716 
      for key, value in self.__dict__.iteritems()]
12717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12718 
 
12719 
  def __eq__(self, other):
12720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12721 
 
12722 
  def __ne__(self, other):
12723 
    return not (self == other)
12724 
 
12725 
class addTag_result:
12726 
  """
12727 
  Attributes:
12728 
   - success
12729 
  """
12730 
 
12731 
  thrift_spec = (
12732 
    (0, TType.BOOL, 'success', None, None, ), # 0
12733 
  )
12734 
 
12735 
  def __init__(self, success=None,):
12736 
    self.success = success
12737 
 
12738 
  def read(self, iprot):
12739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12741 
      return
12742 
    iprot.readStructBegin()
12743 
    while True:
12744 
      (fname, ftype, fid) = iprot.readFieldBegin()
12745 
      if ftype == TType.STOP:
12746 
        break
12747 
      if fid == 0:
12748 
        if ftype == TType.BOOL:
12749 
          self.success = iprot.readBool();
12750 
        else:
12751 
          iprot.skip(ftype)
12752 
      else:
12753 
        iprot.skip(ftype)
12754 
      iprot.readFieldEnd()
12755 
    iprot.readStructEnd()
12756 
 
12757 
  def write(self, oprot):
12758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12760 
      return
12761 
    oprot.writeStructBegin('addTag_result')
12762 
    if self.success is not None:
12763 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12764 
      oprot.writeBool(self.success)
12765 
      oprot.writeFieldEnd()
12766 
    oprot.writeFieldStop()
12767 
    oprot.writeStructEnd()
12768 
 
12769 
  def validate(self):
12770 
    return
12771 
 
12772 
 
12773 
  def __repr__(self):
12774 
    L = ['%s=%r' % (key, value)
12775 
      for key, value in self.__dict__.iteritems()]
12776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12777 
 
12778 
  def __eq__(self, other):
12779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12780 
 
12781 
  def __ne__(self, other):
12782 
    return not (self == other)
12783 
 
12784 
class deleteEntityTag_args:
12785 
  """
12786 
  Attributes:
12787 
   - displayName
12788 
   - itemId
12789 
  """
12790 
 
12791 
  thrift_spec = (
12792 
    None, # 0
12793 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12794 
    (2, TType.I64, 'itemId', None, None, ), # 2
12795 
  )
12796 
 
12797 
  def __init__(self, displayName=None, itemId=None,):
12798 
    self.displayName = displayName
12799 
    self.itemId = itemId
12800 
 
12801 
  def read(self, iprot):
12802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12804 
      return
12805 
    iprot.readStructBegin()
12806 
    while True:
12807 
      (fname, ftype, fid) = iprot.readFieldBegin()
12808 
      if ftype == TType.STOP:
12809 
        break
12810 
      if fid == 1:
12811 
        if ftype == TType.STRING:
12812 
          self.displayName = iprot.readString();
12813 
        else:
12814 
          iprot.skip(ftype)
12815 
      elif fid == 2:
12816 
        if ftype == TType.I64:
12817 
          self.itemId = iprot.readI64();
12818 
        else:
12819 
          iprot.skip(ftype)
12820 
      else:
12821 
        iprot.skip(ftype)
12822 
      iprot.readFieldEnd()
12823 
    iprot.readStructEnd()
12824 
 
12825 
  def write(self, oprot):
12826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12828 
      return
12829 
    oprot.writeStructBegin('deleteEntityTag_args')
12830 
    if self.displayName is not None:
12831 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12832 
      oprot.writeString(self.displayName)
12833 
      oprot.writeFieldEnd()
12834 
    if self.itemId is not None:
12835 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12836 
      oprot.writeI64(self.itemId)
12837 
      oprot.writeFieldEnd()
12838 
    oprot.writeFieldStop()
12839 
    oprot.writeStructEnd()
12840 
 
12841 
  def validate(self):
12842 
    return
12843 
 
12844 
 
12845 
  def __repr__(self):
12846 
    L = ['%s=%r' % (key, value)
12847 
      for key, value in self.__dict__.iteritems()]
12848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12849 
 
12850 
  def __eq__(self, other):
12851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12852 
 
12853 
  def __ne__(self, other):
12854 
    return not (self == other)
12855 
 
12856 
class deleteEntityTag_result:
12857 
  """
12858 
  Attributes:
12859 
   - success
12860 
  """
12861 
 
12862 
  thrift_spec = (
12863 
    (0, TType.BOOL, 'success', None, None, ), # 0
12864 
  )
12865 
 
12866 
  def __init__(self, success=None,):
12867 
    self.success = success
12868 
 
12869 
  def read(self, iprot):
12870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12872 
      return
12873 
    iprot.readStructBegin()
12874 
    while True:
12875 
      (fname, ftype, fid) = iprot.readFieldBegin()
12876 
      if ftype == TType.STOP:
12877 
        break
12878 
      if fid == 0:
12879 
        if ftype == TType.BOOL:
12880 
          self.success = iprot.readBool();
12881 
        else:
12882 
          iprot.skip(ftype)
12883 
      else:
12884 
        iprot.skip(ftype)
12885 
      iprot.readFieldEnd()
12886 
    iprot.readStructEnd()
12887 
 
12888 
  def write(self, oprot):
12889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12891 
      return
12892 
    oprot.writeStructBegin('deleteEntityTag_result')
12893 
    if self.success is not None:
12894 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12895 
      oprot.writeBool(self.success)
12896 
      oprot.writeFieldEnd()
12897 
    oprot.writeFieldStop()
12898 
    oprot.writeStructEnd()
12899 
 
12900 
  def validate(self):
12901 
    return
12902 
 
12903 
 
12904 
  def __repr__(self):
12905 
    L = ['%s=%r' % (key, value)
12906 
      for key, value in self.__dict__.iteritems()]
12907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12908 
 
12909 
  def __eq__(self, other):
12910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12911 
 
12912 
  def __ne__(self, other):
12913 
    return not (self == other)
12914 
 
12915 
class deleteTag_args:
12916 
  """
12917 
  Attributes:
12918 
   - displayName
12919 
  """
12920 
 
12921 
  thrift_spec = (
12922 
    None, # 0
12923 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12924 
  )
12925 
 
12926 
  def __init__(self, displayName=None,):
12927 
    self.displayName = displayName
12928 
 
12929 
  def read(self, iprot):
12930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12932 
      return
12933 
    iprot.readStructBegin()
12934 
    while True:
12935 
      (fname, ftype, fid) = iprot.readFieldBegin()
12936 
      if ftype == TType.STOP:
12937 
        break
12938 
      if fid == 1:
12939 
        if ftype == TType.STRING:
12940 
          self.displayName = iprot.readString();
12941 
        else:
12942 
          iprot.skip(ftype)
12943 
      else:
12944 
        iprot.skip(ftype)
12945 
      iprot.readFieldEnd()
12946 
    iprot.readStructEnd()
12947 
 
12948 
  def write(self, oprot):
12949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12951 
      return
12952 
    oprot.writeStructBegin('deleteTag_args')
12953 
    if self.displayName is not None:
12954 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12955 
      oprot.writeString(self.displayName)
12956 
      oprot.writeFieldEnd()
12957 
    oprot.writeFieldStop()
12958 
    oprot.writeStructEnd()
12959 
 
12960 
  def validate(self):
12961 
    return
12962 
 
12963 
 
12964 
  def __repr__(self):
12965 
    L = ['%s=%r' % (key, value)
12966 
      for key, value in self.__dict__.iteritems()]
12967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12968 
 
12969 
  def __eq__(self, other):
12970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12971 
 
12972 
  def __ne__(self, other):
12973 
    return not (self == other)
12974 
 
12975 
class deleteTag_result:
12976 
  """
12977 
  Attributes:
12978 
   - success
12979 
  """
12980 
 
12981 
  thrift_spec = (
12982 
    (0, TType.BOOL, 'success', None, None, ), # 0
12983 
  )
12984 
 
12985 
  def __init__(self, success=None,):
12986 
    self.success = success
12987 
 
12988 
  def read(self, iprot):
12989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12991 
      return
12992 
    iprot.readStructBegin()
12993 
    while True:
12994 
      (fname, ftype, fid) = iprot.readFieldBegin()
12995 
      if ftype == TType.STOP:
12996 
        break
12997 
      if fid == 0:
12998 
        if ftype == TType.BOOL:
12999 
          self.success = iprot.readBool();
13000 
        else:
13001 
          iprot.skip(ftype)
13002 
      else:
13003 
        iprot.skip(ftype)
13004 
      iprot.readFieldEnd()
13005 
    iprot.readStructEnd()
13006 
 
13007 
  def write(self, oprot):
13008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13010 
      return
13011 
    oprot.writeStructBegin('deleteTag_result')
13012 
    if self.success is not None:
13013 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13014 
      oprot.writeBool(self.success)
13015 
      oprot.writeFieldEnd()
13016 
    oprot.writeFieldStop()
13017 
    oprot.writeStructEnd()
13018 
 
13019 
  def validate(self):
13020 
    return
13021 
 
13022 
 
13023 
  def __repr__(self):
13024 
    L = ['%s=%r' % (key, value)
13025 
      for key, value in self.__dict__.iteritems()]
13026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13027 
 
13028 
  def __eq__(self, other):
13029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13030 
 
13031 
  def __ne__(self, other):
13032 
    return not (self == other)
13033 
 
13034 
class getAllTags_args:
13035 
 
13036 
  thrift_spec = (
13037 
  )
13038 
 
13039 
  def read(self, iprot):
13040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13042 
      return
13043 
    iprot.readStructBegin()
13044 
    while True:
13045 
      (fname, ftype, fid) = iprot.readFieldBegin()
13046 
      if ftype == TType.STOP:
13047 
        break
13048 
      else:
13049 
        iprot.skip(ftype)
13050 
      iprot.readFieldEnd()
13051 
    iprot.readStructEnd()
13052 
 
13053 
  def write(self, oprot):
13054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13056 
      return
13057 
    oprot.writeStructBegin('getAllTags_args')
13058 
    oprot.writeFieldStop()
13059 
    oprot.writeStructEnd()
13060 
 
13061 
  def validate(self):
13062 
    return
13063 
 
13064 
 
13065 
  def __repr__(self):
13066 
    L = ['%s=%r' % (key, value)
13067 
      for key, value in self.__dict__.iteritems()]
13068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13069 
 
13070 
  def __eq__(self, other):
13071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13072 
 
13073 
  def __ne__(self, other):
13074 
    return not (self == other)
13075 
 
13076 
class getAllTags_result:
13077 
  """
13078 
  Attributes:
13079 
   - success
13080 
  """
13081 
 
13082 
  thrift_spec = (
13083 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13084 
  )
13085 
 
13086 
  def __init__(self, success=None,):
13087 
    self.success = success
13088 
 
13089 
  def read(self, iprot):
13090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13092 
      return
13093 
    iprot.readStructBegin()
13094 
    while True:
13095 
      (fname, ftype, fid) = iprot.readFieldBegin()
13096 
      if ftype == TType.STOP:
13097 
        break
13098 
      if fid == 0:
13099 
        if ftype == TType.LIST:
13100 
          self.success = []
8590 kshitij.so 13101 
          (_etype168, _size165) = iprot.readListBegin()
13102 
          for _i169 in xrange(_size165):
13103 
            _elem170 = iprot.readString();
13104 
            self.success.append(_elem170)
6512 kshitij.so 13105 
          iprot.readListEnd()
13106 
        else:
13107 
          iprot.skip(ftype)
13108 
      else:
13109 
        iprot.skip(ftype)
13110 
      iprot.readFieldEnd()
13111 
    iprot.readStructEnd()
13112 
 
13113 
  def write(self, oprot):
13114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13116 
      return
13117 
    oprot.writeStructBegin('getAllTags_result')
13118 
    if self.success is not None:
13119 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13120 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 13121 
      for iter171 in self.success:
13122 
        oprot.writeString(iter171)
6512 kshitij.so 13123 
      oprot.writeListEnd()
13124 
      oprot.writeFieldEnd()
13125 
    oprot.writeFieldStop()
13126 
    oprot.writeStructEnd()
13127 
 
13128 
  def validate(self):
13129 
    return
13130 
 
13131 
 
13132 
  def __repr__(self):
13133 
    L = ['%s=%r' % (key, value)
13134 
      for key, value in self.__dict__.iteritems()]
13135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13136 
 
13137 
  def __eq__(self, other):
13138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13139 
 
13140 
  def __ne__(self, other):
13141 
    return not (self == other)
13142 
 
13143 
class getAllEntitiesByTagName_args:
13144 
  """
13145 
  Attributes:
13146 
   - displayName
13147 
  """
13148 
 
13149 
  thrift_spec = (
13150 
    None, # 0
13151 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13152 
  )
13153 
 
13154 
  def __init__(self, displayName=None,):
13155 
    self.displayName = displayName
13156 
 
13157 
  def read(self, iprot):
13158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13160 
      return
13161 
    iprot.readStructBegin()
13162 
    while True:
13163 
      (fname, ftype, fid) = iprot.readFieldBegin()
13164 
      if ftype == TType.STOP:
13165 
        break
13166 
      if fid == 1:
13167 
        if ftype == TType.STRING:
13168 
          self.displayName = iprot.readString();
13169 
        else:
13170 
          iprot.skip(ftype)
13171 
      else:
13172 
        iprot.skip(ftype)
13173 
      iprot.readFieldEnd()
13174 
    iprot.readStructEnd()
13175 
 
13176 
  def write(self, oprot):
13177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13179 
      return
13180 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
13181 
    if self.displayName is not None:
13182 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13183 
      oprot.writeString(self.displayName)
13184 
      oprot.writeFieldEnd()
13185 
    oprot.writeFieldStop()
13186 
    oprot.writeStructEnd()
13187 
 
13188 
  def validate(self):
13189 
    return
13190 
 
13191 
 
13192 
  def __repr__(self):
13193 
    L = ['%s=%r' % (key, value)
13194 
      for key, value in self.__dict__.iteritems()]
13195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13196 
 
13197 
  def __eq__(self, other):
13198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13199 
 
13200 
  def __ne__(self, other):
13201 
    return not (self == other)
13202 
 
13203 
class getAllEntitiesByTagName_result:
13204 
  """
13205 
  Attributes:
13206 
   - success
13207 
  """
13208 
 
13209 
  thrift_spec = (
13210 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13211 
  )
13212 
 
13213 
  def __init__(self, success=None,):
13214 
    self.success = success
13215 
 
13216 
  def read(self, iprot):
13217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13219 
      return
13220 
    iprot.readStructBegin()
13221 
    while True:
13222 
      (fname, ftype, fid) = iprot.readFieldBegin()
13223 
      if ftype == TType.STOP:
13224 
        break
13225 
      if fid == 0:
13226 
        if ftype == TType.LIST:
13227 
          self.success = []
8590 kshitij.so 13228 
          (_etype175, _size172) = iprot.readListBegin()
13229 
          for _i176 in xrange(_size172):
13230 
            _elem177 = iprot.readI64();
13231 
            self.success.append(_elem177)
6512 kshitij.so 13232 
          iprot.readListEnd()
13233 
        else:
13234 
          iprot.skip(ftype)
13235 
      else:
13236 
        iprot.skip(ftype)
13237 
      iprot.readFieldEnd()
13238 
    iprot.readStructEnd()
13239 
 
13240 
  def write(self, oprot):
13241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13243 
      return
13244 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
13245 
    if self.success is not None:
13246 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13247 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 13248 
      for iter178 in self.success:
13249 
        oprot.writeI64(iter178)
6512 kshitij.so 13250 
      oprot.writeListEnd()
13251 
      oprot.writeFieldEnd()
13252 
    oprot.writeFieldStop()
13253 
    oprot.writeStructEnd()
13254 
 
13255 
  def validate(self):
13256 
    return
13257 
 
13258 
 
13259 
  def __repr__(self):
13260 
    L = ['%s=%r' % (key, value)
13261 
      for key, value in self.__dict__.iteritems()]
13262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13263 
 
13264 
  def __eq__(self, other):
13265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13266 
 
13267 
  def __ne__(self, other):
13268 
    return not (self == other)
13269 
 
6845 amit.gupta 13270 
class getAllEntityTags_args:
13271 
 
13272 
  thrift_spec = (
13273 
  )
13274 
 
13275 
  def read(self, iprot):
13276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13278 
      return
13279 
    iprot.readStructBegin()
13280 
    while True:
13281 
      (fname, ftype, fid) = iprot.readFieldBegin()
13282 
      if ftype == TType.STOP:
13283 
        break
13284 
      else:
13285 
        iprot.skip(ftype)
13286 
      iprot.readFieldEnd()
13287 
    iprot.readStructEnd()
13288 
 
13289 
  def write(self, oprot):
13290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13292 
      return
13293 
    oprot.writeStructBegin('getAllEntityTags_args')
13294 
    oprot.writeFieldStop()
13295 
    oprot.writeStructEnd()
13296 
 
13297 
  def validate(self):
13298 
    return
13299 
 
13300 
 
13301 
  def __repr__(self):
13302 
    L = ['%s=%r' % (key, value)
13303 
      for key, value in self.__dict__.iteritems()]
13304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13305 
 
13306 
  def __eq__(self, other):
13307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13308 
 
13309 
  def __ne__(self, other):
13310 
    return not (self == other)
13311 
 
13312 
class getAllEntityTags_result:
13313 
  """
13314 
  Attributes:
13315 
   - success
13316 
  """
13317 
 
13318 
  thrift_spec = (
13319 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
13320 
  )
13321 
 
13322 
  def __init__(self, success=None,):
13323 
    self.success = success
13324 
 
13325 
  def read(self, iprot):
13326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13328 
      return
13329 
    iprot.readStructBegin()
13330 
    while True:
13331 
      (fname, ftype, fid) = iprot.readFieldBegin()
13332 
      if ftype == TType.STOP:
13333 
        break
13334 
      if fid == 0:
13335 
        if ftype == TType.MAP:
13336 
          self.success = {}
8590 kshitij.so 13337 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
13338 
          for _i183 in xrange(_size179):
13339 
            _key184 = iprot.readI64();
13340 
            _val185 = []
13341 
            (_etype189, _size186) = iprot.readListBegin()
13342 
            for _i190 in xrange(_size186):
13343 
              _elem191 = iprot.readString();
13344 
              _val185.append(_elem191)
6845 amit.gupta 13345 
            iprot.readListEnd()
8590 kshitij.so 13346 
            self.success[_key184] = _val185
6845 amit.gupta 13347 
          iprot.readMapEnd()
13348 
        else:
13349 
          iprot.skip(ftype)
13350 
      else:
13351 
        iprot.skip(ftype)
13352 
      iprot.readFieldEnd()
13353 
    iprot.readStructEnd()
13354 
 
13355 
  def write(self, oprot):
13356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13358 
      return
13359 
    oprot.writeStructBegin('getAllEntityTags_result')
13360 
    if self.success is not None:
13361 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13362 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 13363 
      for kiter192,viter193 in self.success.items():
13364 
        oprot.writeI64(kiter192)
13365 
        oprot.writeListBegin(TType.STRING, len(viter193))
13366 
        for iter194 in viter193:
13367 
          oprot.writeString(iter194)
6845 amit.gupta 13368 
        oprot.writeListEnd()
13369 
      oprot.writeMapEnd()
13370 
      oprot.writeFieldEnd()
13371 
    oprot.writeFieldStop()
13372 
    oprot.writeStructEnd()
13373 
 
13374 
  def validate(self):
13375 
    return
13376 
 
13377 
 
13378 
  def __repr__(self):
13379 
    L = ['%s=%r' % (key, value)
13380 
      for key, value in self.__dict__.iteritems()]
13381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13382 
 
13383 
  def __eq__(self, other):
13384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13385 
 
13386 
  def __ne__(self, other):
13387 
    return not (self == other)
13388 
 
6850 kshitij.so 13389 
class addBanner_args:
13390 
  """
13391 
  Attributes:
8590 kshitij.so 13392 
   - bannerCongregate
6850 kshitij.so 13393 
  """
13394 
 
13395 
  thrift_spec = (
13396 
    None, # 0
8590 kshitij.so 13397 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 13398 
  )
13399 
 
8590 kshitij.so 13400 
  def __init__(self, bannerCongregate=None,):
13401 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 13402 
 
13403 
  def read(self, iprot):
13404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13406 
      return
13407 
    iprot.readStructBegin()
13408 
    while True:
13409 
      (fname, ftype, fid) = iprot.readFieldBegin()
13410 
      if ftype == TType.STOP:
13411 
        break
13412 
      if fid == 1:
8579 kshitij.so 13413 
        if ftype == TType.STRUCT:
8590 kshitij.so 13414 
          self.bannerCongregate = BannerCongregate()
13415 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 13416 
        else:
13417 
          iprot.skip(ftype)
8579 kshitij.so 13418 
      else:
13419 
        iprot.skip(ftype)
13420 
      iprot.readFieldEnd()
13421 
    iprot.readStructEnd()
13422 
 
13423 
  def write(self, oprot):
13424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13426 
      return
13427 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 13428 
    if self.bannerCongregate is not None:
13429 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
13430 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 13431 
      oprot.writeFieldEnd()
13432 
    oprot.writeFieldStop()
13433 
    oprot.writeStructEnd()
13434 
 
13435 
  def validate(self):
13436 
    return
13437 
 
13438 
 
13439 
  def __repr__(self):
13440 
    L = ['%s=%r' % (key, value)
13441 
      for key, value in self.__dict__.iteritems()]
13442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13443 
 
13444 
  def __eq__(self, other):
13445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13446 
 
13447 
  def __ne__(self, other):
13448 
    return not (self == other)
13449 
 
13450 
class addBanner_result:
10097 kshitij.so 13451 
  """
13452 
  Attributes:
13453 
   - success
13454 
  """
8579 kshitij.so 13455 
 
13456 
  thrift_spec = (
10097 kshitij.so 13457 
    (0, TType.BOOL, 'success', None, None, ), # 0
8579 kshitij.so 13458 
  )
13459 
 
10097 kshitij.so 13460 
  def __init__(self, success=None,):
13461 
    self.success = success
13462 
 
8579 kshitij.so 13463 
  def read(self, iprot):
13464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13466 
      return
13467 
    iprot.readStructBegin()
13468 
    while True:
13469 
      (fname, ftype, fid) = iprot.readFieldBegin()
13470 
      if ftype == TType.STOP:
13471 
        break
10097 kshitij.so 13472 
      if fid == 0:
13473 
        if ftype == TType.BOOL:
13474 
          self.success = iprot.readBool();
13475 
        else:
13476 
          iprot.skip(ftype)
8579 kshitij.so 13477 
      else:
13478 
        iprot.skip(ftype)
13479 
      iprot.readFieldEnd()
13480 
    iprot.readStructEnd()
13481 
 
13482 
  def write(self, oprot):
13483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13485 
      return
13486 
    oprot.writeStructBegin('addBanner_result')
10097 kshitij.so 13487 
    if self.success is not None:
13488 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13489 
      oprot.writeBool(self.success)
13490 
      oprot.writeFieldEnd()
8579 kshitij.so 13491 
    oprot.writeFieldStop()
13492 
    oprot.writeStructEnd()
13493 
 
13494 
  def validate(self):
13495 
    return
13496 
 
13497 
 
13498 
  def __repr__(self):
13499 
    L = ['%s=%r' % (key, value)
13500 
      for key, value in self.__dict__.iteritems()]
13501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13502 
 
13503 
  def __eq__(self, other):
13504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13505 
 
13506 
  def __ne__(self, other):
13507 
    return not (self == other)
13508 
 
13509 
class updateBanner_args:
13510 
  """
13511 
  Attributes:
13512 
   - banner
13513 
  """
13514 
 
13515 
  thrift_spec = (
13516 
    None, # 0
13517 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
13518 
  )
13519 
 
13520 
  def __init__(self, banner=None,):
13521 
    self.banner = banner
13522 
 
13523 
  def read(self, iprot):
13524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13526 
      return
13527 
    iprot.readStructBegin()
13528 
    while True:
13529 
      (fname, ftype, fid) = iprot.readFieldBegin()
13530 
      if ftype == TType.STOP:
13531 
        break
13532 
      if fid == 1:
13533 
        if ftype == TType.STRUCT:
13534 
          self.banner = Banner()
13535 
          self.banner.read(iprot)
6850 kshitij.so 13536 
        else:
13537 
          iprot.skip(ftype)
13538 
      else:
13539 
        iprot.skip(ftype)
13540 
      iprot.readFieldEnd()
13541 
    iprot.readStructEnd()
13542 
 
13543 
  def write(self, oprot):
13544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13546 
      return
8579 kshitij.so 13547 
    oprot.writeStructBegin('updateBanner_args')
13548 
    if self.banner is not None:
13549 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
13550 
      self.banner.write(oprot)
6850 kshitij.so 13551 
      oprot.writeFieldEnd()
13552 
    oprot.writeFieldStop()
13553 
    oprot.writeStructEnd()
13554 
 
13555 
  def validate(self):
13556 
    return
13557 
 
13558 
 
13559 
  def __repr__(self):
13560 
    L = ['%s=%r' % (key, value)
13561 
      for key, value in self.__dict__.iteritems()]
13562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13563 
 
13564 
  def __eq__(self, other):
13565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13566 
 
13567 
  def __ne__(self, other):
13568 
    return not (self == other)
13569 
 
8579 kshitij.so 13570 
class updateBanner_result:
6850 kshitij.so 13571 
  """
13572 
  Attributes:
13573 
   - success
13574 
  """
13575 
 
13576 
  thrift_spec = (
13577 
    (0, TType.BOOL, 'success', None, None, ), # 0
13578 
  )
13579 
 
13580 
  def __init__(self, success=None,):
13581 
    self.success = success
13582 
 
13583 
  def read(self, iprot):
13584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13586 
      return
13587 
    iprot.readStructBegin()
13588 
    while True:
13589 
      (fname, ftype, fid) = iprot.readFieldBegin()
13590 
      if ftype == TType.STOP:
13591 
        break
13592 
      if fid == 0:
13593 
        if ftype == TType.BOOL:
13594 
          self.success = iprot.readBool();
13595 
        else:
13596 
          iprot.skip(ftype)
13597 
      else:
13598 
        iprot.skip(ftype)
13599 
      iprot.readFieldEnd()
13600 
    iprot.readStructEnd()
13601 
 
13602 
  def write(self, oprot):
13603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13605 
      return
8579 kshitij.so 13606 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 13607 
    if self.success is not None:
13608 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13609 
      oprot.writeBool(self.success)
13610 
      oprot.writeFieldEnd()
13611 
    oprot.writeFieldStop()
13612 
    oprot.writeStructEnd()
13613 
 
13614 
  def validate(self):
13615 
    return
13616 
 
13617 
 
13618 
  def __repr__(self):
13619 
    L = ['%s=%r' % (key, value)
13620 
      for key, value in self.__dict__.iteritems()]
13621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13622 
 
13623 
  def __eq__(self, other):
13624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13625 
 
13626 
  def __ne__(self, other):
13627 
    return not (self == other)
13628 
 
13629 
class getAllBanners_args:
13630 
 
13631 
  thrift_spec = (
13632 
  )
13633 
 
13634 
  def read(self, iprot):
13635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13637 
      return
13638 
    iprot.readStructBegin()
13639 
    while True:
13640 
      (fname, ftype, fid) = iprot.readFieldBegin()
13641 
      if ftype == TType.STOP:
13642 
        break
13643 
      else:
13644 
        iprot.skip(ftype)
13645 
      iprot.readFieldEnd()
13646 
    iprot.readStructEnd()
13647 
 
13648 
  def write(self, oprot):
13649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13651 
      return
13652 
    oprot.writeStructBegin('getAllBanners_args')
13653 
    oprot.writeFieldStop()
13654 
    oprot.writeStructEnd()
13655 
 
13656 
  def validate(self):
13657 
    return
13658 
 
13659 
 
13660 
  def __repr__(self):
13661 
    L = ['%s=%r' % (key, value)
13662 
      for key, value in self.__dict__.iteritems()]
13663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13664 
 
13665 
  def __eq__(self, other):
13666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13667 
 
13668 
  def __ne__(self, other):
13669 
    return not (self == other)
13670 
 
13671 
class getAllBanners_result:
13672 
  """
13673 
  Attributes:
13674 
   - success
13675 
  """
13676 
 
13677 
  thrift_spec = (
8579 kshitij.so 13678 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 13679 
  )
13680 
 
13681 
  def __init__(self, success=None,):
13682 
    self.success = success
13683 
 
13684 
  def read(self, iprot):
13685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13687 
      return
13688 
    iprot.readStructBegin()
13689 
    while True:
13690 
      (fname, ftype, fid) = iprot.readFieldBegin()
13691 
      if ftype == TType.STOP:
13692 
        break
13693 
      if fid == 0:
13694 
        if ftype == TType.LIST:
13695 
          self.success = []
8590 kshitij.so 13696 
          (_etype198, _size195) = iprot.readListBegin()
13697 
          for _i199 in xrange(_size195):
13698 
            _elem200 = Banner()
13699 
            _elem200.read(iprot)
13700 
            self.success.append(_elem200)
6850 kshitij.so 13701 
          iprot.readListEnd()
13702 
        else:
13703 
          iprot.skip(ftype)
13704 
      else:
13705 
        iprot.skip(ftype)
13706 
      iprot.readFieldEnd()
13707 
    iprot.readStructEnd()
13708 
 
13709 
  def write(self, oprot):
13710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13712 
      return
13713 
    oprot.writeStructBegin('getAllBanners_result')
13714 
    if self.success is not None:
13715 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 13716 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13717 
      for iter201 in self.success:
13718 
        iter201.write(oprot)
6850 kshitij.so 13719 
      oprot.writeListEnd()
13720 
      oprot.writeFieldEnd()
13721 
    oprot.writeFieldStop()
13722 
    oprot.writeStructEnd()
13723 
 
13724 
  def validate(self):
13725 
    return
13726 
 
13727 
 
13728 
  def __repr__(self):
13729 
    L = ['%s=%r' % (key, value)
13730 
      for key, value in self.__dict__.iteritems()]
13731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13732 
 
13733 
  def __eq__(self, other):
13734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13735 
 
13736 
  def __ne__(self, other):
13737 
    return not (self == other)
13738 
 
13739 
class deleteBanner_args:
13740 
  """
13741 
  Attributes:
13742 
   - bannerName
9155 kshitij.so 13743 
   - bannerType
6850 kshitij.so 13744 
  """
13745 
 
13746 
  thrift_spec = (
13747 
    None, # 0
13748 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13749 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13750 
  )
13751 
 
9155 kshitij.so 13752 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13753 
    self.bannerName = bannerName
9155 kshitij.so 13754 
    self.bannerType = bannerType
6850 kshitij.so 13755 
 
13756 
  def read(self, iprot):
13757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13759 
      return
13760 
    iprot.readStructBegin()
13761 
    while True:
13762 
      (fname, ftype, fid) = iprot.readFieldBegin()
13763 
      if ftype == TType.STOP:
13764 
        break
13765 
      if fid == 1:
13766 
        if ftype == TType.STRING:
13767 
          self.bannerName = iprot.readString();
13768 
        else:
13769 
          iprot.skip(ftype)
9155 kshitij.so 13770 
      elif fid == 2:
13771 
        if ftype == TType.I32:
13772 
          self.bannerType = iprot.readI32();
13773 
        else:
13774 
          iprot.skip(ftype)
6850 kshitij.so 13775 
      else:
13776 
        iprot.skip(ftype)
13777 
      iprot.readFieldEnd()
13778 
    iprot.readStructEnd()
13779 
 
13780 
  def write(self, oprot):
13781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13783 
      return
13784 
    oprot.writeStructBegin('deleteBanner_args')
13785 
    if self.bannerName is not None:
13786 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13787 
      oprot.writeString(self.bannerName)
13788 
      oprot.writeFieldEnd()
9155 kshitij.so 13789 
    if self.bannerType is not None:
13790 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13791 
      oprot.writeI32(self.bannerType)
13792 
      oprot.writeFieldEnd()
6850 kshitij.so 13793 
    oprot.writeFieldStop()
13794 
    oprot.writeStructEnd()
13795 
 
13796 
  def validate(self):
13797 
    return
13798 
 
13799 
 
13800 
  def __repr__(self):
13801 
    L = ['%s=%r' % (key, value)
13802 
      for key, value in self.__dict__.iteritems()]
13803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13804 
 
13805 
  def __eq__(self, other):
13806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13807 
 
13808 
  def __ne__(self, other):
13809 
    return not (self == other)
13810 
 
13811 
class deleteBanner_result:
13812 
  """
13813 
  Attributes:
13814 
   - success
13815 
  """
13816 
 
13817 
  thrift_spec = (
13818 
    (0, TType.BOOL, 'success', None, None, ), # 0
13819 
  )
13820 
 
13821 
  def __init__(self, success=None,):
13822 
    self.success = success
13823 
 
13824 
  def read(self, iprot):
13825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13827 
      return
13828 
    iprot.readStructBegin()
13829 
    while True:
13830 
      (fname, ftype, fid) = iprot.readFieldBegin()
13831 
      if ftype == TType.STOP:
13832 
        break
13833 
      if fid == 0:
13834 
        if ftype == TType.BOOL:
13835 
          self.success = iprot.readBool();
13836 
        else:
13837 
          iprot.skip(ftype)
13838 
      else:
13839 
        iprot.skip(ftype)
13840 
      iprot.readFieldEnd()
13841 
    iprot.readStructEnd()
13842 
 
13843 
  def write(self, oprot):
13844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13846 
      return
13847 
    oprot.writeStructBegin('deleteBanner_result')
13848 
    if self.success is not None:
13849 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13850 
      oprot.writeBool(self.success)
13851 
      oprot.writeFieldEnd()
13852 
    oprot.writeFieldStop()
13853 
    oprot.writeStructEnd()
13854 
 
13855 
  def validate(self):
13856 
    return
13857 
 
13858 
 
13859 
  def __repr__(self):
13860 
    L = ['%s=%r' % (key, value)
13861 
      for key, value in self.__dict__.iteritems()]
13862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13863 
 
13864 
  def __eq__(self, other):
13865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13866 
 
13867 
  def __ne__(self, other):
13868 
    return not (self == other)
13869 
 
13870 
class getBannerDetails_args:
13871 
  """
13872 
  Attributes:
13873 
   - bannerName
9155 kshitij.so 13874 
   - bannerType
6850 kshitij.so 13875 
  """
13876 
 
13877 
  thrift_spec = (
13878 
    None, # 0
13879 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13880 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13881 
  )
13882 
 
9155 kshitij.so 13883 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13884 
    self.bannerName = bannerName
9155 kshitij.so 13885 
    self.bannerType = bannerType
6850 kshitij.so 13886 
 
13887 
  def read(self, iprot):
13888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13890 
      return
13891 
    iprot.readStructBegin()
13892 
    while True:
13893 
      (fname, ftype, fid) = iprot.readFieldBegin()
13894 
      if ftype == TType.STOP:
13895 
        break
13896 
      if fid == 1:
13897 
        if ftype == TType.STRING:
13898 
          self.bannerName = iprot.readString();
13899 
        else:
13900 
          iprot.skip(ftype)
9155 kshitij.so 13901 
      elif fid == 2:
13902 
        if ftype == TType.I32:
13903 
          self.bannerType = iprot.readI32();
13904 
        else:
13905 
          iprot.skip(ftype)
6850 kshitij.so 13906 
      else:
13907 
        iprot.skip(ftype)
13908 
      iprot.readFieldEnd()
13909 
    iprot.readStructEnd()
13910 
 
13911 
  def write(self, oprot):
13912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13914 
      return
13915 
    oprot.writeStructBegin('getBannerDetails_args')
13916 
    if self.bannerName is not None:
13917 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13918 
      oprot.writeString(self.bannerName)
13919 
      oprot.writeFieldEnd()
9155 kshitij.so 13920 
    if self.bannerType is not None:
13921 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13922 
      oprot.writeI32(self.bannerType)
13923 
      oprot.writeFieldEnd()
6850 kshitij.so 13924 
    oprot.writeFieldStop()
13925 
    oprot.writeStructEnd()
13926 
 
13927 
  def validate(self):
13928 
    return
13929 
 
13930 
 
13931 
  def __repr__(self):
13932 
    L = ['%s=%r' % (key, value)
13933 
      for key, value in self.__dict__.iteritems()]
13934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13935 
 
13936 
  def __eq__(self, other):
13937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13938 
 
13939 
  def __ne__(self, other):
13940 
    return not (self == other)
13941 
 
13942 
class getBannerDetails_result:
13943 
  """
13944 
  Attributes:
13945 
   - success
13946 
  """
13947 
 
13948 
  thrift_spec = (
13949 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
13950 
  )
13951 
 
13952 
  def __init__(self, success=None,):
13953 
    self.success = success
13954 
 
13955 
  def read(self, iprot):
13956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13958 
      return
13959 
    iprot.readStructBegin()
13960 
    while True:
13961 
      (fname, ftype, fid) = iprot.readFieldBegin()
13962 
      if ftype == TType.STOP:
13963 
        break
13964 
      if fid == 0:
13965 
        if ftype == TType.STRUCT:
13966 
          self.success = Banner()
13967 
          self.success.read(iprot)
13968 
        else:
13969 
          iprot.skip(ftype)
13970 
      else:
13971 
        iprot.skip(ftype)
13972 
      iprot.readFieldEnd()
13973 
    iprot.readStructEnd()
13974 
 
13975 
  def write(self, oprot):
13976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13978 
      return
13979 
    oprot.writeStructBegin('getBannerDetails_result')
13980 
    if self.success is not None:
13981 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13982 
      self.success.write(oprot)
13983 
      oprot.writeFieldEnd()
13984 
    oprot.writeFieldStop()
13985 
    oprot.writeStructEnd()
13986 
 
13987 
  def validate(self):
13988 
    return
13989 
 
13990 
 
13991 
  def __repr__(self):
13992 
    L = ['%s=%r' % (key, value)
13993 
      for key, value in self.__dict__.iteritems()]
13994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13995 
 
13996 
  def __eq__(self, other):
13997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13998 
 
13999 
  def __ne__(self, other):
14000 
    return not (self == other)
14001 
 
14002 
class getActiveBanners_args:
14003 
 
14004 
  thrift_spec = (
14005 
  )
14006 
 
14007 
  def read(self, iprot):
14008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14010 
      return
14011 
    iprot.readStructBegin()
14012 
    while True:
14013 
      (fname, ftype, fid) = iprot.readFieldBegin()
14014 
      if ftype == TType.STOP:
14015 
        break
14016 
      else:
14017 
        iprot.skip(ftype)
14018 
      iprot.readFieldEnd()
14019 
    iprot.readStructEnd()
14020 
 
14021 
  def write(self, oprot):
14022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14024 
      return
14025 
    oprot.writeStructBegin('getActiveBanners_args')
14026 
    oprot.writeFieldStop()
14027 
    oprot.writeStructEnd()
14028 
 
14029 
  def validate(self):
14030 
    return
14031 
 
14032 
 
14033 
  def __repr__(self):
14034 
    L = ['%s=%r' % (key, value)
14035 
      for key, value in self.__dict__.iteritems()]
14036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14037 
 
14038 
  def __eq__(self, other):
14039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14040 
 
14041 
  def __ne__(self, other):
14042 
    return not (self == other)
14043 
 
14044 
class getActiveBanners_result:
14045 
  """
14046 
  Attributes:
14047 
   - success
14048 
  """
14049 
 
14050 
  thrift_spec = (
8579 kshitij.so 14051 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 14052 
  )
14053 
 
14054 
  def __init__(self, success=None,):
14055 
    self.success = success
14056 
 
14057 
  def read(self, iprot):
14058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14060 
      return
14061 
    iprot.readStructBegin()
14062 
    while True:
14063 
      (fname, ftype, fid) = iprot.readFieldBegin()
14064 
      if ftype == TType.STOP:
14065 
        break
14066 
      if fid == 0:
8579 kshitij.so 14067 
        if ftype == TType.MAP:
14068 
          self.success = {}
8590 kshitij.so 14069 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
14070 
          for _i206 in xrange(_size202):
14071 
            _key207 = iprot.readString();
14072 
            _val208 = []
14073 
            (_etype212, _size209) = iprot.readListBegin()
14074 
            for _i213 in xrange(_size209):
14075 
              _elem214 = Banner()
14076 
              _elem214.read(iprot)
14077 
              _val208.append(_elem214)
8579 kshitij.so 14078 
            iprot.readListEnd()
8590 kshitij.so 14079 
            self.success[_key207] = _val208
8579 kshitij.so 14080 
          iprot.readMapEnd()
6850 kshitij.so 14081 
        else:
14082 
          iprot.skip(ftype)
14083 
      else:
14084 
        iprot.skip(ftype)
14085 
      iprot.readFieldEnd()
14086 
    iprot.readStructEnd()
14087 
 
14088 
  def write(self, oprot):
14089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14091 
      return
14092 
    oprot.writeStructBegin('getActiveBanners_result')
14093 
    if self.success is not None:
8579 kshitij.so 14094 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14095 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 14096 
      for kiter215,viter216 in self.success.items():
14097 
        oprot.writeString(kiter215)
14098 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
14099 
        for iter217 in viter216:
14100 
          iter217.write(oprot)
8579 kshitij.so 14101 
        oprot.writeListEnd()
14102 
      oprot.writeMapEnd()
6850 kshitij.so 14103 
      oprot.writeFieldEnd()
14104 
    oprot.writeFieldStop()
14105 
    oprot.writeStructEnd()
14106 
 
14107 
  def validate(self):
14108 
    return
14109 
 
14110 
 
14111 
  def __repr__(self):
14112 
    L = ['%s=%r' % (key, value)
14113 
      for key, value in self.__dict__.iteritems()]
14114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14115 
 
14116 
  def __eq__(self, other):
14117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14118 
 
14119 
  def __ne__(self, other):
14120 
    return not (self == other)
14121 
 
6849 kshitij.so 14122 
class addBannerMap_args:
14123 
  """
14124 
  Attributes:
8579 kshitij.so 14125 
   - bannerMaps
6849 kshitij.so 14126 
  """
14127 
 
14128 
  thrift_spec = (
14129 
    None, # 0
8579 kshitij.so 14130 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 14131 
  )
14132 
 
8579 kshitij.so 14133 
  def __init__(self, bannerMaps=None,):
14134 
    self.bannerMaps = bannerMaps
6849 kshitij.so 14135 
 
14136 
  def read(self, iprot):
14137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14139 
      return
14140 
    iprot.readStructBegin()
14141 
    while True:
14142 
      (fname, ftype, fid) = iprot.readFieldBegin()
14143 
      if ftype == TType.STOP:
14144 
        break
14145 
      if fid == 1:
8579 kshitij.so 14146 
        if ftype == TType.LIST:
14147 
          self.bannerMaps = []
8590 kshitij.so 14148 
          (_etype221, _size218) = iprot.readListBegin()
14149 
          for _i222 in xrange(_size218):
14150 
            _elem223 = BannerMap()
14151 
            _elem223.read(iprot)
14152 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 14153 
          iprot.readListEnd()
6849 kshitij.so 14154 
        else:
14155 
          iprot.skip(ftype)
8579 kshitij.so 14156 
      else:
14157 
        iprot.skip(ftype)
14158 
      iprot.readFieldEnd()
14159 
    iprot.readStructEnd()
14160 
 
14161 
  def write(self, oprot):
14162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14164 
      return
14165 
    oprot.writeStructBegin('addBannerMap_args')
14166 
    if self.bannerMaps is not None:
14167 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
14168 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 14169 
      for iter224 in self.bannerMaps:
14170 
        iter224.write(oprot)
8579 kshitij.so 14171 
      oprot.writeListEnd()
14172 
      oprot.writeFieldEnd()
14173 
    oprot.writeFieldStop()
14174 
    oprot.writeStructEnd()
14175 
 
14176 
  def validate(self):
14177 
    return
14178 
 
14179 
 
14180 
  def __repr__(self):
14181 
    L = ['%s=%r' % (key, value)
14182 
      for key, value in self.__dict__.iteritems()]
14183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14184 
 
14185 
  def __eq__(self, other):
14186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14187 
 
14188 
  def __ne__(self, other):
14189 
    return not (self == other)
14190 
 
14191 
class addBannerMap_result:
14192 
  """
14193 
  Attributes:
14194 
   - success
14195 
  """
14196 
 
14197 
  thrift_spec = (
14198 
    (0, TType.BOOL, 'success', None, None, ), # 0
14199 
  )
14200 
 
14201 
  def __init__(self, success=None,):
14202 
    self.success = success
14203 
 
14204 
  def read(self, iprot):
14205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14207 
      return
14208 
    iprot.readStructBegin()
14209 
    while True:
14210 
      (fname, ftype, fid) = iprot.readFieldBegin()
14211 
      if ftype == TType.STOP:
14212 
        break
14213 
      if fid == 0:
14214 
        if ftype == TType.BOOL:
14215 
          self.success = iprot.readBool();
6849 kshitij.so 14216 
        else:
14217 
          iprot.skip(ftype)
8579 kshitij.so 14218 
      else:
14219 
        iprot.skip(ftype)
14220 
      iprot.readFieldEnd()
14221 
    iprot.readStructEnd()
14222 
 
14223 
  def write(self, oprot):
14224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14226 
      return
14227 
    oprot.writeStructBegin('addBannerMap_result')
14228 
    if self.success is not None:
14229 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14230 
      oprot.writeBool(self.success)
14231 
      oprot.writeFieldEnd()
14232 
    oprot.writeFieldStop()
14233 
    oprot.writeStructEnd()
14234 
 
14235 
  def validate(self):
14236 
    return
14237 
 
14238 
 
14239 
  def __repr__(self):
14240 
    L = ['%s=%r' % (key, value)
14241 
      for key, value in self.__dict__.iteritems()]
14242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14243 
 
14244 
  def __eq__(self, other):
14245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14246 
 
14247 
  def __ne__(self, other):
14248 
    return not (self == other)
14249 
 
14250 
class updateBannerMap_args:
14251 
  """
14252 
  Attributes:
14253 
   - bannerMap
14254 
  """
14255 
 
14256 
  thrift_spec = (
14257 
    None, # 0
14258 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
14259 
  )
14260 
 
14261 
  def __init__(self, bannerMap=None,):
14262 
    self.bannerMap = bannerMap
14263 
 
14264 
  def read(self, iprot):
14265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14267 
      return
14268 
    iprot.readStructBegin()
14269 
    while True:
14270 
      (fname, ftype, fid) = iprot.readFieldBegin()
14271 
      if ftype == TType.STOP:
14272 
        break
14273 
      if fid == 1:
14274 
        if ftype == TType.STRUCT:
14275 
          self.bannerMap = BannerMap()
14276 
          self.bannerMap.read(iprot)
6849 kshitij.so 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
8579 kshitij.so 14288 
    oprot.writeStructBegin('updateBannerMap_args')
14289 
    if self.bannerMap is not None:
14290 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
14291 
      self.bannerMap.write(oprot)
6849 kshitij.so 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 
 
8579 kshitij.so 14311 
class updateBannerMap_result:
6849 kshitij.so 14312 
  """
14313 
  Attributes:
14314 
   - success
14315 
  """
14316 
 
14317 
  thrift_spec = (
14318 
    (0, TType.BOOL, 'success', None, None, ), # 0
14319 
  )
14320 
 
14321 
  def __init__(self, success=None,):
14322 
    self.success = success
14323 
 
14324 
  def read(self, iprot):
14325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14327 
      return
14328 
    iprot.readStructBegin()
14329 
    while True:
14330 
      (fname, ftype, fid) = iprot.readFieldBegin()
14331 
      if ftype == TType.STOP:
14332 
        break
14333 
      if fid == 0:
14334 
        if ftype == TType.BOOL:
14335 
          self.success = iprot.readBool();
14336 
        else:
14337 
          iprot.skip(ftype)
14338 
      else:
14339 
        iprot.skip(ftype)
14340 
      iprot.readFieldEnd()
14341 
    iprot.readStructEnd()
14342 
 
14343 
  def write(self, oprot):
14344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14346 
      return
8579 kshitij.so 14347 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 14348 
    if self.success is not None:
14349 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14350 
      oprot.writeBool(self.success)
14351 
      oprot.writeFieldEnd()
14352 
    oprot.writeFieldStop()
14353 
    oprot.writeStructEnd()
14354 
 
14355 
  def validate(self):
14356 
    return
14357 
 
14358 
 
14359 
  def __repr__(self):
14360 
    L = ['%s=%r' % (key, value)
14361 
      for key, value in self.__dict__.iteritems()]
14362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14363 
 
14364 
  def __eq__(self, other):
14365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14366 
 
14367 
  def __ne__(self, other):
14368 
    return not (self == other)
14369 
 
14370 
class deleteBannerMap_args:
14371 
  """
14372 
  Attributes:
14373 
   - bannerName
14374 
  """
14375 
 
14376 
  thrift_spec = (
14377 
    None, # 0
14378 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
14379 
  )
14380 
 
14381 
  def __init__(self, bannerName=None,):
14382 
    self.bannerName = bannerName
14383 
 
14384 
  def read(self, iprot):
14385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14387 
      return
14388 
    iprot.readStructBegin()
14389 
    while True:
14390 
      (fname, ftype, fid) = iprot.readFieldBegin()
14391 
      if ftype == TType.STOP:
14392 
        break
14393 
      if fid == 1:
14394 
        if ftype == TType.STRING:
14395 
          self.bannerName = iprot.readString();
14396 
        else:
14397 
          iprot.skip(ftype)
14398 
      else:
14399 
        iprot.skip(ftype)
14400 
      iprot.readFieldEnd()
14401 
    iprot.readStructEnd()
14402 
 
14403 
  def write(self, oprot):
14404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14406 
      return
14407 
    oprot.writeStructBegin('deleteBannerMap_args')
14408 
    if self.bannerName is not None:
14409 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14410 
      oprot.writeString(self.bannerName)
14411 
      oprot.writeFieldEnd()
14412 
    oprot.writeFieldStop()
14413 
    oprot.writeStructEnd()
14414 
 
14415 
  def validate(self):
14416 
    return
14417 
 
14418 
 
14419 
  def __repr__(self):
14420 
    L = ['%s=%r' % (key, value)
14421 
      for key, value in self.__dict__.iteritems()]
14422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14423 
 
14424 
  def __eq__(self, other):
14425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14426 
 
14427 
  def __ne__(self, other):
14428 
    return not (self == other)
14429 
 
14430 
class deleteBannerMap_result:
14431 
  """
14432 
  Attributes:
14433 
   - success
14434 
  """
14435 
 
14436 
  thrift_spec = (
14437 
    (0, TType.BOOL, 'success', None, None, ), # 0
14438 
  )
14439 
 
14440 
  def __init__(self, success=None,):
14441 
    self.success = success
14442 
 
14443 
  def read(self, iprot):
14444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14446 
      return
14447 
    iprot.readStructBegin()
14448 
    while True:
14449 
      (fname, ftype, fid) = iprot.readFieldBegin()
14450 
      if ftype == TType.STOP:
14451 
        break
14452 
      if fid == 0:
14453 
        if ftype == TType.BOOL:
14454 
          self.success = iprot.readBool();
14455 
        else:
14456 
          iprot.skip(ftype)
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('deleteBannerMap_result')
14467 
    if self.success is not None:
14468 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14469 
      oprot.writeBool(self.success)
14470 
      oprot.writeFieldEnd()
14471 
    oprot.writeFieldStop()
14472 
    oprot.writeStructEnd()
14473 
 
14474 
  def validate(self):
14475 
    return
14476 
 
14477 
 
14478 
  def __repr__(self):
14479 
    L = ['%s=%r' % (key, value)
14480 
      for key, value in self.__dict__.iteritems()]
14481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14482 
 
14483 
  def __eq__(self, other):
14484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14485 
 
14486 
  def __ne__(self, other):
14487 
    return not (self == other)
14488 
 
14489 
class getBannerMapDetails_args:
14490 
  """
14491 
  Attributes:
14492 
   - bannerName
9155 kshitij.so 14493 
   - bannerType
6849 kshitij.so 14494 
  """
14495 
 
14496 
  thrift_spec = (
14497 
    None, # 0
14498 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14499 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 14500 
  )
14501 
 
9155 kshitij.so 14502 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 14503 
    self.bannerName = bannerName
9155 kshitij.so 14504 
    self.bannerType = bannerType
6849 kshitij.so 14505 
 
14506 
  def read(self, iprot):
14507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14509 
      return
14510 
    iprot.readStructBegin()
14511 
    while True:
14512 
      (fname, ftype, fid) = iprot.readFieldBegin()
14513 
      if ftype == TType.STOP:
14514 
        break
14515 
      if fid == 1:
14516 
        if ftype == TType.STRING:
14517 
          self.bannerName = iprot.readString();
14518 
        else:
14519 
          iprot.skip(ftype)
9155 kshitij.so 14520 
      elif fid == 2:
14521 
        if ftype == TType.I32:
14522 
          self.bannerType = iprot.readI32();
14523 
        else:
14524 
          iprot.skip(ftype)
6849 kshitij.so 14525 
      else:
14526 
        iprot.skip(ftype)
14527 
      iprot.readFieldEnd()
14528 
    iprot.readStructEnd()
14529 
 
14530 
  def write(self, oprot):
14531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14533 
      return
14534 
    oprot.writeStructBegin('getBannerMapDetails_args')
14535 
    if self.bannerName is not None:
14536 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14537 
      oprot.writeString(self.bannerName)
14538 
      oprot.writeFieldEnd()
9155 kshitij.so 14539 
    if self.bannerType is not None:
14540 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14541 
      oprot.writeI32(self.bannerType)
14542 
      oprot.writeFieldEnd()
6849 kshitij.so 14543 
    oprot.writeFieldStop()
14544 
    oprot.writeStructEnd()
14545 
 
14546 
  def validate(self):
14547 
    return
14548 
 
14549 
 
14550 
  def __repr__(self):
14551 
    L = ['%s=%r' % (key, value)
14552 
      for key, value in self.__dict__.iteritems()]
14553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14554 
 
14555 
  def __eq__(self, other):
14556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14557 
 
14558 
  def __ne__(self, other):
14559 
    return not (self == other)
14560 
 
14561 
class getBannerMapDetails_result:
14562 
  """
14563 
  Attributes:
14564 
   - success
14565 
  """
14566 
 
14567 
  thrift_spec = (
14568 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
14569 
  )
14570 
 
14571 
  def __init__(self, success=None,):
14572 
    self.success = success
14573 
 
14574 
  def read(self, iprot):
14575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14577 
      return
14578 
    iprot.readStructBegin()
14579 
    while True:
14580 
      (fname, ftype, fid) = iprot.readFieldBegin()
14581 
      if ftype == TType.STOP:
14582 
        break
14583 
      if fid == 0:
14584 
        if ftype == TType.LIST:
14585 
          self.success = []
8590 kshitij.so 14586 
          (_etype228, _size225) = iprot.readListBegin()
14587 
          for _i229 in xrange(_size225):
14588 
            _elem230 = BannerMap()
14589 
            _elem230.read(iprot)
14590 
            self.success.append(_elem230)
6849 kshitij.so 14591 
          iprot.readListEnd()
14592 
        else:
14593 
          iprot.skip(ftype)
14594 
      else:
14595 
        iprot.skip(ftype)
14596 
      iprot.readFieldEnd()
14597 
    iprot.readStructEnd()
14598 
 
14599 
  def write(self, oprot):
14600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14602 
      return
14603 
    oprot.writeStructBegin('getBannerMapDetails_result')
14604 
    if self.success is not None:
14605 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14606 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14607 
      for iter231 in self.success:
14608 
        iter231.write(oprot)
6849 kshitij.so 14609 
      oprot.writeListEnd()
14610 
      oprot.writeFieldEnd()
14611 
    oprot.writeFieldStop()
14612 
    oprot.writeStructEnd()
14613 
 
14614 
  def validate(self):
14615 
    return
14616 
 
14617 
 
14618 
  def __repr__(self):
14619 
    L = ['%s=%r' % (key, value)
14620 
      for key, value in self.__dict__.iteritems()]
14621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14622 
 
14623 
  def __eq__(self, other):
14624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14625 
 
14626 
  def __ne__(self, other):
14627 
    return not (self == other)
14628 
 
8579 kshitij.so 14629 
class addBannerUri_args:
14630 
  """
14631 
  Attributes:
14632 
   - bannerUriMappings
14633 
  """
14634 
 
14635 
  thrift_spec = (
14636 
    None, # 0
14637 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
14638 
  )
14639 
 
14640 
  def __init__(self, bannerUriMappings=None,):
14641 
    self.bannerUriMappings = bannerUriMappings
14642 
 
14643 
  def read(self, iprot):
14644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14646 
      return
14647 
    iprot.readStructBegin()
14648 
    while True:
14649 
      (fname, ftype, fid) = iprot.readFieldBegin()
14650 
      if ftype == TType.STOP:
14651 
        break
14652 
      if fid == 1:
14653 
        if ftype == TType.LIST:
14654 
          self.bannerUriMappings = []
8590 kshitij.so 14655 
          (_etype235, _size232) = iprot.readListBegin()
14656 
          for _i236 in xrange(_size232):
14657 
            _elem237 = BannerUriMapping()
14658 
            _elem237.read(iprot)
14659 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 14660 
          iprot.readListEnd()
14661 
        else:
14662 
          iprot.skip(ftype)
14663 
      else:
14664 
        iprot.skip(ftype)
14665 
      iprot.readFieldEnd()
14666 
    iprot.readStructEnd()
14667 
 
14668 
  def write(self, oprot):
14669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14671 
      return
14672 
    oprot.writeStructBegin('addBannerUri_args')
14673 
    if self.bannerUriMappings is not None:
14674 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
14675 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 14676 
      for iter238 in self.bannerUriMappings:
14677 
        iter238.write(oprot)
8579 kshitij.so 14678 
      oprot.writeListEnd()
14679 
      oprot.writeFieldEnd()
14680 
    oprot.writeFieldStop()
14681 
    oprot.writeStructEnd()
14682 
 
14683 
  def validate(self):
14684 
    return
14685 
 
14686 
 
14687 
  def __repr__(self):
14688 
    L = ['%s=%r' % (key, value)
14689 
      for key, value in self.__dict__.iteritems()]
14690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14691 
 
14692 
  def __eq__(self, other):
14693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14694 
 
14695 
  def __ne__(self, other):
14696 
    return not (self == other)
14697 
 
14698 
class addBannerUri_result:
14699 
 
14700 
  thrift_spec = (
14701 
  )
14702 
 
14703 
  def read(self, iprot):
14704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14706 
      return
14707 
    iprot.readStructBegin()
14708 
    while True:
14709 
      (fname, ftype, fid) = iprot.readFieldBegin()
14710 
      if ftype == TType.STOP:
14711 
        break
14712 
      else:
14713 
        iprot.skip(ftype)
14714 
      iprot.readFieldEnd()
14715 
    iprot.readStructEnd()
14716 
 
14717 
  def write(self, oprot):
14718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14720 
      return
14721 
    oprot.writeStructBegin('addBannerUri_result')
14722 
    oprot.writeFieldStop()
14723 
    oprot.writeStructEnd()
14724 
 
14725 
  def validate(self):
14726 
    return
14727 
 
14728 
 
14729 
  def __repr__(self):
14730 
    L = ['%s=%r' % (key, value)
14731 
      for key, value in self.__dict__.iteritems()]
14732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14733 
 
14734 
  def __eq__(self, other):
14735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14736 
 
14737 
  def __ne__(self, other):
14738 
    return not (self == other)
14739 
 
14740 
class getUriMapping_args:
14741 
  """
14742 
  Attributes:
14743 
   - bannerName
9155 kshitij.so 14744 
   - bannerType
8579 kshitij.so 14745 
  """
14746 
 
14747 
  thrift_spec = (
14748 
    None, # 0
14749 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14750 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 14751 
  )
14752 
 
9155 kshitij.so 14753 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 14754 
    self.bannerName = bannerName
9155 kshitij.so 14755 
    self.bannerType = bannerType
8579 kshitij.so 14756 
 
14757 
  def read(self, iprot):
14758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14760 
      return
14761 
    iprot.readStructBegin()
14762 
    while True:
14763 
      (fname, ftype, fid) = iprot.readFieldBegin()
14764 
      if ftype == TType.STOP:
14765 
        break
14766 
      if fid == 1:
14767 
        if ftype == TType.STRING:
14768 
          self.bannerName = iprot.readString();
14769 
        else:
14770 
          iprot.skip(ftype)
9155 kshitij.so 14771 
      elif fid == 2:
14772 
        if ftype == TType.I32:
14773 
          self.bannerType = iprot.readI32();
14774 
        else:
14775 
          iprot.skip(ftype)
8579 kshitij.so 14776 
      else:
14777 
        iprot.skip(ftype)
14778 
      iprot.readFieldEnd()
14779 
    iprot.readStructEnd()
14780 
 
14781 
  def write(self, oprot):
14782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14784 
      return
14785 
    oprot.writeStructBegin('getUriMapping_args')
14786 
    if self.bannerName is not None:
14787 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14788 
      oprot.writeString(self.bannerName)
14789 
      oprot.writeFieldEnd()
9155 kshitij.so 14790 
    if self.bannerType is not None:
14791 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14792 
      oprot.writeI32(self.bannerType)
14793 
      oprot.writeFieldEnd()
8579 kshitij.so 14794 
    oprot.writeFieldStop()
14795 
    oprot.writeStructEnd()
14796 
 
14797 
  def validate(self):
14798 
    return
14799 
 
14800 
 
14801 
  def __repr__(self):
14802 
    L = ['%s=%r' % (key, value)
14803 
      for key, value in self.__dict__.iteritems()]
14804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14805 
 
14806 
  def __eq__(self, other):
14807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14808 
 
14809 
  def __ne__(self, other):
14810 
    return not (self == other)
14811 
 
14812 
class getUriMapping_result:
14813 
  """
14814 
  Attributes:
14815 
   - success
14816 
  """
14817 
 
14818 
  thrift_spec = (
14819 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
14820 
  )
14821 
 
14822 
  def __init__(self, success=None,):
14823 
    self.success = success
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 == 0:
14835 
        if ftype == TType.LIST:
14836 
          self.success = []
8590 kshitij.so 14837 
          (_etype242, _size239) = iprot.readListBegin()
14838 
          for _i243 in xrange(_size239):
14839 
            _elem244 = BannerUriMapping()
14840 
            _elem244.read(iprot)
14841 
            self.success.append(_elem244)
8579 kshitij.so 14842 
          iprot.readListEnd()
14843 
        else:
14844 
          iprot.skip(ftype)
14845 
      else:
14846 
        iprot.skip(ftype)
14847 
      iprot.readFieldEnd()
14848 
    iprot.readStructEnd()
14849 
 
14850 
  def write(self, oprot):
14851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14853 
      return
14854 
    oprot.writeStructBegin('getUriMapping_result')
14855 
    if self.success is not None:
14856 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14857 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14858 
      for iter245 in self.success:
14859 
        iter245.write(oprot)
8579 kshitij.so 14860 
      oprot.writeListEnd()
14861 
      oprot.writeFieldEnd()
14862 
    oprot.writeFieldStop()
14863 
    oprot.writeStructEnd()
14864 
 
14865 
  def validate(self):
14866 
    return
14867 
 
14868 
 
14869 
  def __repr__(self):
14870 
    L = ['%s=%r' % (key, value)
14871 
      for key, value in self.__dict__.iteritems()]
14872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14873 
 
14874 
  def __eq__(self, other):
14875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14876 
 
14877 
  def __ne__(self, other):
14878 
    return not (self == other)
14879 
 
14880 
class addCampaign_args:
14881 
  """
14882 
  Attributes:
14883 
   - campaign
14884 
  """
14885 
 
14886 
  thrift_spec = (
14887 
    None, # 0
14888 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
14889 
  )
14890 
 
14891 
  def __init__(self, campaign=None,):
14892 
    self.campaign = campaign
14893 
 
14894 
  def read(self, iprot):
14895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14897 
      return
14898 
    iprot.readStructBegin()
14899 
    while True:
14900 
      (fname, ftype, fid) = iprot.readFieldBegin()
14901 
      if ftype == TType.STOP:
14902 
        break
14903 
      if fid == 1:
14904 
        if ftype == TType.STRUCT:
14905 
          self.campaign = Campaign()
14906 
          self.campaign.read(iprot)
14907 
        else:
14908 
          iprot.skip(ftype)
14909 
      else:
14910 
        iprot.skip(ftype)
14911 
      iprot.readFieldEnd()
14912 
    iprot.readStructEnd()
14913 
 
14914 
  def write(self, oprot):
14915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14917 
      return
14918 
    oprot.writeStructBegin('addCampaign_args')
14919 
    if self.campaign is not None:
14920 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
14921 
      self.campaign.write(oprot)
14922 
      oprot.writeFieldEnd()
14923 
    oprot.writeFieldStop()
14924 
    oprot.writeStructEnd()
14925 
 
14926 
  def validate(self):
14927 
    return
14928 
 
14929 
 
14930 
  def __repr__(self):
14931 
    L = ['%s=%r' % (key, value)
14932 
      for key, value in self.__dict__.iteritems()]
14933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14934 
 
14935 
  def __eq__(self, other):
14936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14937 
 
14938 
  def __ne__(self, other):
14939 
    return not (self == other)
14940 
 
14941 
class addCampaign_result:
14942 
 
14943 
  thrift_spec = (
14944 
  )
14945 
 
14946 
  def read(self, iprot):
14947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14949 
      return
14950 
    iprot.readStructBegin()
14951 
    while True:
14952 
      (fname, ftype, fid) = iprot.readFieldBegin()
14953 
      if ftype == TType.STOP:
14954 
        break
14955 
      else:
14956 
        iprot.skip(ftype)
14957 
      iprot.readFieldEnd()
14958 
    iprot.readStructEnd()
14959 
 
14960 
  def write(self, oprot):
14961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14963 
      return
14964 
    oprot.writeStructBegin('addCampaign_result')
14965 
    oprot.writeFieldStop()
14966 
    oprot.writeStructEnd()
14967 
 
14968 
  def validate(self):
14969 
    return
14970 
 
14971 
 
14972 
  def __repr__(self):
14973 
    L = ['%s=%r' % (key, value)
14974 
      for key, value in self.__dict__.iteritems()]
14975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14976 
 
14977 
  def __eq__(self, other):
14978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14979 
 
14980 
  def __ne__(self, other):
14981 
    return not (self == other)
14982 
 
14983 
class getCampaigns_args:
14984 
  """
14985 
  Attributes:
14986 
   - campaignName
14987 
  """
14988 
 
14989 
  thrift_spec = (
14990 
    None, # 0
14991 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
14992 
  )
14993 
 
14994 
  def __init__(self, campaignName=None,):
14995 
    self.campaignName = campaignName
14996 
 
14997 
  def read(self, iprot):
14998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15000 
      return
15001 
    iprot.readStructBegin()
15002 
    while True:
15003 
      (fname, ftype, fid) = iprot.readFieldBegin()
15004 
      if ftype == TType.STOP:
15005 
        break
15006 
      if fid == 1:
15007 
        if ftype == TType.STRING:
15008 
          self.campaignName = iprot.readString();
15009 
        else:
15010 
          iprot.skip(ftype)
15011 
      else:
15012 
        iprot.skip(ftype)
15013 
      iprot.readFieldEnd()
15014 
    iprot.readStructEnd()
15015 
 
15016 
  def write(self, oprot):
15017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15019 
      return
15020 
    oprot.writeStructBegin('getCampaigns_args')
15021 
    if self.campaignName is not None:
15022 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
15023 
      oprot.writeString(self.campaignName)
15024 
      oprot.writeFieldEnd()
15025 
    oprot.writeFieldStop()
15026 
    oprot.writeStructEnd()
15027 
 
15028 
  def validate(self):
15029 
    return
15030 
 
15031 
 
15032 
  def __repr__(self):
15033 
    L = ['%s=%r' % (key, value)
15034 
      for key, value in self.__dict__.iteritems()]
15035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15036 
 
15037 
  def __eq__(self, other):
15038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15039 
 
15040 
  def __ne__(self, other):
15041 
    return not (self == other)
15042 
 
15043 
class getCampaigns_result:
15044 
  """
15045 
  Attributes:
15046 
   - success
15047 
  """
15048 
 
15049 
  thrift_spec = (
15050 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
15051 
  )
15052 
 
15053 
  def __init__(self, success=None,):
15054 
    self.success = success
15055 
 
15056 
  def read(self, iprot):
15057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15059 
      return
15060 
    iprot.readStructBegin()
15061 
    while True:
15062 
      (fname, ftype, fid) = iprot.readFieldBegin()
15063 
      if ftype == TType.STOP:
15064 
        break
15065 
      if fid == 0:
15066 
        if ftype == TType.LIST:
15067 
          self.success = []
8590 kshitij.so 15068 
          (_etype249, _size246) = iprot.readListBegin()
15069 
          for _i250 in xrange(_size246):
15070 
            _elem251 = Campaign()
15071 
            _elem251.read(iprot)
15072 
            self.success.append(_elem251)
8579 kshitij.so 15073 
          iprot.readListEnd()
15074 
        else:
15075 
          iprot.skip(ftype)
15076 
      else:
15077 
        iprot.skip(ftype)
15078 
      iprot.readFieldEnd()
15079 
    iprot.readStructEnd()
15080 
 
15081 
  def write(self, oprot):
15082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15084 
      return
15085 
    oprot.writeStructBegin('getCampaigns_result')
15086 
    if self.success is not None:
15087 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15088 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15089 
      for iter252 in self.success:
15090 
        iter252.write(oprot)
8579 kshitij.so 15091 
      oprot.writeListEnd()
15092 
      oprot.writeFieldEnd()
15093 
    oprot.writeFieldStop()
15094 
    oprot.writeStructEnd()
15095 
 
15096 
  def validate(self):
15097 
    return
15098 
 
15099 
 
15100 
  def __repr__(self):
15101 
    L = ['%s=%r' % (key, value)
15102 
      for key, value in self.__dict__.iteritems()]
15103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15104 
 
15105 
  def __eq__(self, other):
15106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15107 
 
15108 
  def __ne__(self, other):
15109 
    return not (self == other)
15110 
 
15111 
class deleteCampaign_args:
15112 
  """
15113 
  Attributes:
15114 
   - campaignId
15115 
  """
15116 
 
15117 
  thrift_spec = (
15118 
    None, # 0
15119 
    (1, TType.I64, 'campaignId', None, None, ), # 1
15120 
  )
15121 
 
15122 
  def __init__(self, campaignId=None,):
15123 
    self.campaignId = campaignId
15124 
 
15125 
  def read(self, iprot):
15126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15128 
      return
15129 
    iprot.readStructBegin()
15130 
    while True:
15131 
      (fname, ftype, fid) = iprot.readFieldBegin()
15132 
      if ftype == TType.STOP:
15133 
        break
15134 
      if fid == 1:
15135 
        if ftype == TType.I64:
15136 
          self.campaignId = iprot.readI64();
15137 
        else:
15138 
          iprot.skip(ftype)
15139 
      else:
15140 
        iprot.skip(ftype)
15141 
      iprot.readFieldEnd()
15142 
    iprot.readStructEnd()
15143 
 
15144 
  def write(self, oprot):
15145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15147 
      return
15148 
    oprot.writeStructBegin('deleteCampaign_args')
15149 
    if self.campaignId is not None:
15150 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
15151 
      oprot.writeI64(self.campaignId)
15152 
      oprot.writeFieldEnd()
15153 
    oprot.writeFieldStop()
15154 
    oprot.writeStructEnd()
15155 
 
15156 
  def validate(self):
15157 
    return
15158 
 
15159 
 
15160 
  def __repr__(self):
15161 
    L = ['%s=%r' % (key, value)
15162 
      for key, value in self.__dict__.iteritems()]
15163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15164 
 
15165 
  def __eq__(self, other):
15166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15167 
 
15168 
  def __ne__(self, other):
15169 
    return not (self == other)
15170 
 
15171 
class deleteCampaign_result:
15172 
 
15173 
  thrift_spec = (
15174 
  )
15175 
 
15176 
  def read(self, iprot):
15177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15179 
      return
15180 
    iprot.readStructBegin()
15181 
    while True:
15182 
      (fname, ftype, fid) = iprot.readFieldBegin()
15183 
      if ftype == TType.STOP:
15184 
        break
15185 
      else:
15186 
        iprot.skip(ftype)
15187 
      iprot.readFieldEnd()
15188 
    iprot.readStructEnd()
15189 
 
15190 
  def write(self, oprot):
15191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15193 
      return
15194 
    oprot.writeStructBegin('deleteCampaign_result')
15195 
    oprot.writeFieldStop()
15196 
    oprot.writeStructEnd()
15197 
 
15198 
  def validate(self):
15199 
    return
15200 
 
15201 
 
15202 
  def __repr__(self):
15203 
    L = ['%s=%r' % (key, value)
15204 
      for key, value in self.__dict__.iteritems()]
15205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15206 
 
15207 
  def __eq__(self, other):
15208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15209 
 
15210 
  def __ne__(self, other):
15211 
    return not (self == other)
15212 
 
15213 
class getAllCampaigns_args:
15214 
 
15215 
  thrift_spec = (
15216 
  )
15217 
 
15218 
  def read(self, iprot):
15219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15221 
      return
15222 
    iprot.readStructBegin()
15223 
    while True:
15224 
      (fname, ftype, fid) = iprot.readFieldBegin()
15225 
      if ftype == TType.STOP:
15226 
        break
15227 
      else:
15228 
        iprot.skip(ftype)
15229 
      iprot.readFieldEnd()
15230 
    iprot.readStructEnd()
15231 
 
15232 
  def write(self, oprot):
15233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15235 
      return
15236 
    oprot.writeStructBegin('getAllCampaigns_args')
15237 
    oprot.writeFieldStop()
15238 
    oprot.writeStructEnd()
15239 
 
15240 
  def validate(self):
15241 
    return
15242 
 
15243 
 
15244 
  def __repr__(self):
15245 
    L = ['%s=%r' % (key, value)
15246 
      for key, value in self.__dict__.iteritems()]
15247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15248 
 
15249 
  def __eq__(self, other):
15250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15251 
 
15252 
  def __ne__(self, other):
15253 
    return not (self == other)
15254 
 
15255 
class getAllCampaigns_result:
15256 
  """
15257 
  Attributes:
15258 
   - success
15259 
  """
15260 
 
15261 
  thrift_spec = (
15262 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15263 
  )
15264 
 
15265 
  def __init__(self, success=None,):
15266 
    self.success = success
15267 
 
15268 
  def read(self, iprot):
15269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15271 
      return
15272 
    iprot.readStructBegin()
15273 
    while True:
15274 
      (fname, ftype, fid) = iprot.readFieldBegin()
15275 
      if ftype == TType.STOP:
15276 
        break
15277 
      if fid == 0:
15278 
        if ftype == TType.LIST:
15279 
          self.success = []
8590 kshitij.so 15280 
          (_etype256, _size253) = iprot.readListBegin()
15281 
          for _i257 in xrange(_size253):
15282 
            _elem258 = iprot.readString();
15283 
            self.success.append(_elem258)
8579 kshitij.so 15284 
          iprot.readListEnd()
15285 
        else:
15286 
          iprot.skip(ftype)
15287 
      else:
15288 
        iprot.skip(ftype)
15289 
      iprot.readFieldEnd()
15290 
    iprot.readStructEnd()
15291 
 
15292 
  def write(self, oprot):
15293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15295 
      return
15296 
    oprot.writeStructBegin('getAllCampaigns_result')
15297 
    if self.success is not None:
15298 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15299 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 15300 
      for iter259 in self.success:
15301 
        oprot.writeString(iter259)
8579 kshitij.so 15302 
      oprot.writeListEnd()
15303 
      oprot.writeFieldEnd()
15304 
    oprot.writeFieldStop()
15305 
    oprot.writeStructEnd()
15306 
 
15307 
  def validate(self):
15308 
    return
15309 
 
15310 
 
15311 
  def __repr__(self):
15312 
    L = ['%s=%r' % (key, value)
15313 
      for key, value in self.__dict__.iteritems()]
15314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15315 
 
15316 
  def __eq__(self, other):
15317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15318 
 
15319 
  def __ne__(self, other):
15320 
    return not (self == other)
15321 
 
9155 kshitij.so 15322 
class getActiveBannersForMobileSite_args:
15323 
 
15324 
  thrift_spec = (
15325 
  )
15326 
 
15327 
  def read(self, iprot):
15328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15330 
      return
15331 
    iprot.readStructBegin()
15332 
    while True:
15333 
      (fname, ftype, fid) = iprot.readFieldBegin()
15334 
      if ftype == TType.STOP:
15335 
        break
15336 
      else:
15337 
        iprot.skip(ftype)
15338 
      iprot.readFieldEnd()
15339 
    iprot.readStructEnd()
15340 
 
15341 
  def write(self, oprot):
15342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15344 
      return
15345 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
15346 
    oprot.writeFieldStop()
15347 
    oprot.writeStructEnd()
15348 
 
15349 
  def validate(self):
15350 
    return
15351 
 
15352 
 
15353 
  def __repr__(self):
15354 
    L = ['%s=%r' % (key, value)
15355 
      for key, value in self.__dict__.iteritems()]
15356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15357 
 
15358 
  def __eq__(self, other):
15359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15360 
 
15361 
  def __ne__(self, other):
15362 
    return not (self == other)
15363 
 
15364 
class getActiveBannersForMobileSite_result:
15365 
  """
15366 
  Attributes:
15367 
   - success
15368 
  """
15369 
 
15370 
  thrift_spec = (
15371 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
15372 
  )
15373 
 
15374 
  def __init__(self, success=None,):
15375 
    self.success = success
15376 
 
15377 
  def read(self, iprot):
15378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15380 
      return
15381 
    iprot.readStructBegin()
15382 
    while True:
15383 
      (fname, ftype, fid) = iprot.readFieldBegin()
15384 
      if ftype == TType.STOP:
15385 
        break
15386 
      if fid == 0:
15387 
        if ftype == TType.MAP:
15388 
          self.success = {}
15389 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
15390 
          for _i264 in xrange(_size260):
15391 
            _key265 = iprot.readString();
15392 
            _val266 = []
15393 
            (_etype270, _size267) = iprot.readListBegin()
15394 
            for _i271 in xrange(_size267):
15395 
              _elem272 = Banner()
15396 
              _elem272.read(iprot)
15397 
              _val266.append(_elem272)
15398 
            iprot.readListEnd()
15399 
            self.success[_key265] = _val266
15400 
          iprot.readMapEnd()
15401 
        else:
15402 
          iprot.skip(ftype)
15403 
      else:
15404 
        iprot.skip(ftype)
15405 
      iprot.readFieldEnd()
15406 
    iprot.readStructEnd()
15407 
 
15408 
  def write(self, oprot):
15409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15411 
      return
15412 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
15413 
    if self.success is not None:
15414 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15415 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
15416 
      for kiter273,viter274 in self.success.items():
15417 
        oprot.writeString(kiter273)
15418 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
15419 
        for iter275 in viter274:
15420 
          iter275.write(oprot)
15421 
        oprot.writeListEnd()
15422 
      oprot.writeMapEnd()
15423 
      oprot.writeFieldEnd()
15424 
    oprot.writeFieldStop()
15425 
    oprot.writeStructEnd()
15426 
 
15427 
  def validate(self):
15428 
    return
15429 
 
15430 
 
15431 
  def __repr__(self):
15432 
    L = ['%s=%r' % (key, value)
15433 
      for key, value in self.__dict__.iteritems()]
15434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15435 
 
15436 
  def __eq__(self, other):
15437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15438 
 
15439 
  def __ne__(self, other):
15440 
    return not (self == other)
15441 
 
5944 mandeep.dh 15442 
class deleteSimilarItem_args:
15443 
  """
15444 
  Attributes:
15445 
   - itemId
15446 
   - catalogItemId
15447 
  """
15448 
 
15449 
  thrift_spec = (
15450 
    None, # 0
15451 
    (1, TType.I64, 'itemId', None, None, ), # 1
15452 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
15453 
  )
15454 
 
15455 
  def __init__(self, itemId=None, catalogItemId=None,):
15456 
    self.itemId = itemId
15457 
    self.catalogItemId = catalogItemId
15458 
 
15459 
  def read(self, iprot):
15460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15462 
      return
15463 
    iprot.readStructBegin()
15464 
    while True:
15465 
      (fname, ftype, fid) = iprot.readFieldBegin()
15466 
      if ftype == TType.STOP:
15467 
        break
15468 
      if fid == 1:
15469 
        if ftype == TType.I64:
15470 
          self.itemId = iprot.readI64();
15471 
        else:
15472 
          iprot.skip(ftype)
15473 
      elif fid == 2:
15474 
        if ftype == TType.I64:
15475 
          self.catalogItemId = iprot.readI64();
15476 
        else:
15477 
          iprot.skip(ftype)
15478 
      else:
15479 
        iprot.skip(ftype)
15480 
      iprot.readFieldEnd()
15481 
    iprot.readStructEnd()
15482 
 
15483 
  def write(self, oprot):
15484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15486 
      return
15487 
    oprot.writeStructBegin('deleteSimilarItem_args')
15488 
    if self.itemId is not None:
15489 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15490 
      oprot.writeI64(self.itemId)
15491 
      oprot.writeFieldEnd()
15492 
    if self.catalogItemId is not None:
15493 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
15494 
      oprot.writeI64(self.catalogItemId)
15495 
      oprot.writeFieldEnd()
15496 
    oprot.writeFieldStop()
15497 
    oprot.writeStructEnd()
15498 
 
15499 
  def validate(self):
15500 
    return
15501 
 
15502 
 
15503 
  def __repr__(self):
15504 
    L = ['%s=%r' % (key, value)
15505 
      for key, value in self.__dict__.iteritems()]
15506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15507 
 
15508 
  def __eq__(self, other):
15509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15510 
 
15511 
  def __ne__(self, other):
15512 
    return not (self == other)
15513 
 
15514 
class deleteSimilarItem_result:
15515 
  """
15516 
  Attributes:
15517 
   - success
15518 
   - cex
15519 
  """
15520 
 
15521 
  thrift_spec = (
15522 
    (0, TType.BOOL, 'success', None, None, ), # 0
15523 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15524 
  )
15525 
 
15526 
  def __init__(self, success=None, cex=None,):
15527 
    self.success = success
15528 
    self.cex = cex
15529 
 
15530 
  def read(self, iprot):
15531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15533 
      return
15534 
    iprot.readStructBegin()
15535 
    while True:
15536 
      (fname, ftype, fid) = iprot.readFieldBegin()
15537 
      if ftype == TType.STOP:
15538 
        break
15539 
      if fid == 0:
15540 
        if ftype == TType.BOOL:
15541 
          self.success = iprot.readBool();
15542 
        else:
15543 
          iprot.skip(ftype)
15544 
      elif fid == 1:
15545 
        if ftype == TType.STRUCT:
15546 
          self.cex = CatalogServiceException()
15547 
          self.cex.read(iprot)
15548 
        else:
15549 
          iprot.skip(ftype)
15550 
      else:
15551 
        iprot.skip(ftype)
15552 
      iprot.readFieldEnd()
15553 
    iprot.readStructEnd()
15554 
 
15555 
  def write(self, oprot):
15556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15558 
      return
15559 
    oprot.writeStructBegin('deleteSimilarItem_result')
15560 
    if self.success is not None:
15561 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15562 
      oprot.writeBool(self.success)
15563 
      oprot.writeFieldEnd()
15564 
    if self.cex is not None:
15565 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15566 
      self.cex.write(oprot)
15567 
      oprot.writeFieldEnd()
15568 
    oprot.writeFieldStop()
15569 
    oprot.writeStructEnd()
15570 
 
15571 
  def validate(self):
15572 
    return
15573 
 
15574 
 
15575 
  def __repr__(self):
15576 
    L = ['%s=%r' % (key, value)
15577 
      for key, value in self.__dict__.iteritems()]
15578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15579 
 
15580 
  def __eq__(self, other):
15581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15582 
 
15583 
  def __ne__(self, other):
15584 
    return not (self == other)
15585 
 
15586 
class checkSimilarItem_args:
15587 
  """
15588 
  Attributes:
15589 
   - brand
15590 
   - modelNumber
15591 
   - modelName
15592 
   - color
15593 
  """
15594 
 
15595 
  thrift_spec = (
15596 
    None, # 0
15597 
    (1, TType.STRING, 'brand', None, None, ), # 1
15598 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
15599 
    (3, TType.STRING, 'modelName', None, None, ), # 3
15600 
    (4, TType.STRING, 'color', None, None, ), # 4
15601 
  )
15602 
 
15603 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
15604 
    self.brand = brand
15605 
    self.modelNumber = modelNumber
15606 
    self.modelName = modelName
15607 
    self.color = color
15608 
 
15609 
  def read(self, iprot):
15610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15612 
      return
15613 
    iprot.readStructBegin()
15614 
    while True:
15615 
      (fname, ftype, fid) = iprot.readFieldBegin()
15616 
      if ftype == TType.STOP:
15617 
        break
15618 
      if fid == 1:
15619 
        if ftype == TType.STRING:
15620 
          self.brand = iprot.readString();
15621 
        else:
15622 
          iprot.skip(ftype)
15623 
      elif fid == 2:
15624 
        if ftype == TType.STRING:
15625 
          self.modelNumber = iprot.readString();
15626 
        else:
15627 
          iprot.skip(ftype)
15628 
      elif fid == 3:
15629 
        if ftype == TType.STRING:
15630 
          self.modelName = iprot.readString();
15631 
        else:
15632 
          iprot.skip(ftype)
15633 
      elif fid == 4:
15634 
        if ftype == TType.STRING:
15635 
          self.color = iprot.readString();
15636 
        else:
15637 
          iprot.skip(ftype)
15638 
      else:
15639 
        iprot.skip(ftype)
15640 
      iprot.readFieldEnd()
15641 
    iprot.readStructEnd()
15642 
 
15643 
  def write(self, oprot):
15644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15646 
      return
15647 
    oprot.writeStructBegin('checkSimilarItem_args')
15648 
    if self.brand is not None:
15649 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
15650 
      oprot.writeString(self.brand)
15651 
      oprot.writeFieldEnd()
15652 
    if self.modelNumber is not None:
15653 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
15654 
      oprot.writeString(self.modelNumber)
15655 
      oprot.writeFieldEnd()
15656 
    if self.modelName is not None:
15657 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
15658 
      oprot.writeString(self.modelName)
15659 
      oprot.writeFieldEnd()
15660 
    if self.color is not None:
15661 
      oprot.writeFieldBegin('color', TType.STRING, 4)
15662 
      oprot.writeString(self.color)
15663 
      oprot.writeFieldEnd()
15664 
    oprot.writeFieldStop()
15665 
    oprot.writeStructEnd()
15666 
 
15667 
  def validate(self):
15668 
    return
15669 
 
15670 
 
15671 
  def __repr__(self):
15672 
    L = ['%s=%r' % (key, value)
15673 
      for key, value in self.__dict__.iteritems()]
15674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15675 
 
15676 
  def __eq__(self, other):
15677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15678 
 
15679 
  def __ne__(self, other):
15680 
    return not (self == other)
15681 
 
15682 
class checkSimilarItem_result:
15683 
  """
15684 
  Attributes:
15685 
   - success
15686 
  """
15687 
 
15688 
  thrift_spec = (
15689 
    (0, TType.I64, 'success', None, None, ), # 0
15690 
  )
15691 
 
15692 
  def __init__(self, success=None,):
15693 
    self.success = success
15694 
 
15695 
  def read(self, iprot):
15696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15698 
      return
15699 
    iprot.readStructBegin()
15700 
    while True:
15701 
      (fname, ftype, fid) = iprot.readFieldBegin()
15702 
      if ftype == TType.STOP:
15703 
        break
15704 
      if fid == 0:
15705 
        if ftype == TType.I64:
15706 
          self.success = iprot.readI64();
15707 
        else:
15708 
          iprot.skip(ftype)
15709 
      else:
15710 
        iprot.skip(ftype)
15711 
      iprot.readFieldEnd()
15712 
    iprot.readStructEnd()
15713 
 
15714 
  def write(self, oprot):
15715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15717 
      return
15718 
    oprot.writeStructBegin('checkSimilarItem_result')
15719 
    if self.success is not None:
15720 
      oprot.writeFieldBegin('success', TType.I64, 0)
15721 
      oprot.writeI64(self.success)
15722 
      oprot.writeFieldEnd()
15723 
    oprot.writeFieldStop()
15724 
    oprot.writeStructEnd()
15725 
 
15726 
  def validate(self):
15727 
    return
15728 
 
15729 
 
15730 
  def __repr__(self):
15731 
    L = ['%s=%r' % (key, value)
15732 
      for key, value in self.__dict__.iteritems()]
15733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15734 
 
15735 
  def __eq__(self, other):
15736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15737 
 
15738 
  def __ne__(self, other):
15739 
    return not (self == other)
15740 
 
15741 
class validateRiskyStatus_args:
15742 
  """
15743 
  Attributes:
15744 
   - itemId
15745 
  """
15746 
 
15747 
  thrift_spec = (
15748 
    None, # 0
15749 
    (1, TType.I64, 'itemId', None, None, ), # 1
15750 
  )
15751 
 
15752 
  def __init__(self, itemId=None,):
15753 
    self.itemId = itemId
15754 
 
15755 
  def read(self, iprot):
15756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15758 
      return
15759 
    iprot.readStructBegin()
15760 
    while True:
15761 
      (fname, ftype, fid) = iprot.readFieldBegin()
15762 
      if ftype == TType.STOP:
15763 
        break
15764 
      if fid == 1:
15765 
        if ftype == TType.I64:
15766 
          self.itemId = iprot.readI64();
15767 
        else:
15768 
          iprot.skip(ftype)
15769 
      else:
15770 
        iprot.skip(ftype)
15771 
      iprot.readFieldEnd()
15772 
    iprot.readStructEnd()
15773 
 
15774 
  def write(self, oprot):
15775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15777 
      return
15778 
    oprot.writeStructBegin('validateRiskyStatus_args')
15779 
    if self.itemId is not None:
15780 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15781 
      oprot.writeI64(self.itemId)
15782 
      oprot.writeFieldEnd()
15783 
    oprot.writeFieldStop()
15784 
    oprot.writeStructEnd()
15785 
 
15786 
  def validate(self):
15787 
    return
15788 
 
15789 
 
15790 
  def __repr__(self):
15791 
    L = ['%s=%r' % (key, value)
15792 
      for key, value in self.__dict__.iteritems()]
15793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15794 
 
15795 
  def __eq__(self, other):
15796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15797 
 
15798 
  def __ne__(self, other):
15799 
    return not (self == other)
15800 
 
15801 
class validateRiskyStatus_result:
15802 
 
15803 
  thrift_spec = (
15804 
  )
15805 
 
15806 
  def read(self, iprot):
15807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15809 
      return
15810 
    iprot.readStructBegin()
15811 
    while True:
15812 
      (fname, ftype, fid) = iprot.readFieldBegin()
15813 
      if ftype == TType.STOP:
15814 
        break
15815 
      else:
15816 
        iprot.skip(ftype)
15817 
      iprot.readFieldEnd()
15818 
    iprot.readStructEnd()
15819 
 
15820 
  def write(self, oprot):
15821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15823 
      return
15824 
    oprot.writeStructBegin('validateRiskyStatus_result')
15825 
    oprot.writeFieldStop()
15826 
    oprot.writeStructEnd()
15827 
 
15828 
  def validate(self):
15829 
    return
15830 
 
15831 
 
15832 
  def __repr__(self):
15833 
    L = ['%s=%r' % (key, value)
15834 
      for key, value in self.__dict__.iteritems()]
15835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15836 
 
15837 
  def __eq__(self, other):
15838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15839 
 
15840 
  def __ne__(self, other):
15841 
    return not (self == other)
15842 
 
15843 
class changeItemRiskyFlag_args:
15844 
  """
15845 
  Attributes:
15846 
   - itemId
15847 
   - risky
15848 
  """
15849 
 
15850 
  thrift_spec = (
15851 
    None, # 0
15852 
    (1, TType.I64, 'itemId', None, None, ), # 1
15853 
    (2, TType.BOOL, 'risky', None, None, ), # 2
15854 
  )
15855 
 
15856 
  def __init__(self, itemId=None, risky=None,):
15857 
    self.itemId = itemId
15858 
    self.risky = risky
15859 
 
15860 
  def read(self, iprot):
15861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15863 
      return
15864 
    iprot.readStructBegin()
15865 
    while True:
15866 
      (fname, ftype, fid) = iprot.readFieldBegin()
15867 
      if ftype == TType.STOP:
15868 
        break
15869 
      if fid == 1:
15870 
        if ftype == TType.I64:
15871 
          self.itemId = iprot.readI64();
15872 
        else:
15873 
          iprot.skip(ftype)
15874 
      elif fid == 2:
15875 
        if ftype == TType.BOOL:
15876 
          self.risky = iprot.readBool();
15877 
        else:
15878 
          iprot.skip(ftype)
15879 
      else:
15880 
        iprot.skip(ftype)
15881 
      iprot.readFieldEnd()
15882 
    iprot.readStructEnd()
15883 
 
15884 
  def write(self, oprot):
15885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15887 
      return
15888 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
15889 
    if self.itemId is not None:
15890 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15891 
      oprot.writeI64(self.itemId)
15892 
      oprot.writeFieldEnd()
15893 
    if self.risky is not None:
15894 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
15895 
      oprot.writeBool(self.risky)
15896 
      oprot.writeFieldEnd()
15897 
    oprot.writeFieldStop()
15898 
    oprot.writeStructEnd()
15899 
 
15900 
  def validate(self):
15901 
    return
15902 
 
15903 
 
15904 
  def __repr__(self):
15905 
    L = ['%s=%r' % (key, value)
15906 
      for key, value in self.__dict__.iteritems()]
15907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15908 
 
15909 
  def __eq__(self, other):
15910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15911 
 
15912 
  def __ne__(self, other):
15913 
    return not (self == other)
15914 
 
15915 
class changeItemRiskyFlag_result:
15916 
 
15917 
  thrift_spec = (
15918 
  )
15919 
 
15920 
  def read(self, iprot):
15921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15923 
      return
15924 
    iprot.readStructBegin()
15925 
    while True:
15926 
      (fname, ftype, fid) = iprot.readFieldBegin()
15927 
      if ftype == TType.STOP:
15928 
        break
15929 
      else:
15930 
        iprot.skip(ftype)
15931 
      iprot.readFieldEnd()
15932 
    iprot.readStructEnd()
15933 
 
15934 
  def write(self, oprot):
15935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15937 
      return
15938 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
15939 
    oprot.writeFieldStop()
15940 
    oprot.writeStructEnd()
15941 
 
15942 
  def validate(self):
15943 
    return
15944 
 
15945 
 
15946 
  def __repr__(self):
15947 
    L = ['%s=%r' % (key, value)
15948 
      for key, value in self.__dict__.iteritems()]
15949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15950 
 
15951 
  def __eq__(self, other):
15952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15953 
 
15954 
  def __ne__(self, other):
15955 
    return not (self == other)
15956 
 
15957 
class getItemsByRiskyFlag_args:
15958 
 
15959 
  thrift_spec = (
15960 
  )
15961 
 
15962 
  def read(self, iprot):
15963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15965 
      return
15966 
    iprot.readStructBegin()
15967 
    while True:
15968 
      (fname, ftype, fid) = iprot.readFieldBegin()
15969 
      if ftype == TType.STOP:
15970 
        break
15971 
      else:
15972 
        iprot.skip(ftype)
15973 
      iprot.readFieldEnd()
15974 
    iprot.readStructEnd()
15975 
 
15976 
  def write(self, oprot):
15977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15979 
      return
15980 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
15981 
    oprot.writeFieldStop()
15982 
    oprot.writeStructEnd()
15983 
 
15984 
  def validate(self):
15985 
    return
15986 
 
15987 
 
15988 
  def __repr__(self):
15989 
    L = ['%s=%r' % (key, value)
15990 
      for key, value in self.__dict__.iteritems()]
15991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15992 
 
15993 
  def __eq__(self, other):
15994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15995 
 
15996 
  def __ne__(self, other):
15997 
    return not (self == other)
15998 
 
15999 
class getItemsByRiskyFlag_result:
16000 
  """
16001 
  Attributes:
16002 
   - success
16003 
  """
16004 
 
16005 
  thrift_spec = (
16006 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16007 
  )
16008 
 
16009 
  def __init__(self, success=None,):
16010 
    self.success = success
16011 
 
16012 
  def read(self, iprot):
16013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16015 
      return
16016 
    iprot.readStructBegin()
16017 
    while True:
16018 
      (fname, ftype, fid) = iprot.readFieldBegin()
16019 
      if ftype == TType.STOP:
16020 
        break
16021 
      if fid == 0:
16022 
        if ftype == TType.LIST:
16023 
          self.success = []
9155 kshitij.so 16024 
          (_etype279, _size276) = iprot.readListBegin()
16025 
          for _i280 in xrange(_size276):
16026 
            _elem281 = Item()
16027 
            _elem281.read(iprot)
16028 
            self.success.append(_elem281)
5944 mandeep.dh 16029 
          iprot.readListEnd()
16030 
        else:
16031 
          iprot.skip(ftype)
16032 
      else:
16033 
        iprot.skip(ftype)
16034 
      iprot.readFieldEnd()
16035 
    iprot.readStructEnd()
16036 
 
16037 
  def write(self, oprot):
16038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16040 
      return
16041 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
16042 
    if self.success is not None:
16043 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16044 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16045 
      for iter282 in self.success:
16046 
        iter282.write(oprot)
5944 mandeep.dh 16047 
      oprot.writeListEnd()
16048 
      oprot.writeFieldEnd()
16049 
    oprot.writeFieldStop()
16050 
    oprot.writeStructEnd()
16051 
 
16052 
  def validate(self):
16053 
    return
16054 
 
16055 
 
16056 
  def __repr__(self):
16057 
    L = ['%s=%r' % (key, value)
16058 
      for key, value in self.__dict__.iteritems()]
16059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16060 
 
16061 
  def __eq__(self, other):
16062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16063 
 
16064 
  def __ne__(self, other):
16065 
    return not (self == other)
16066 
 
16067 
class getItemsForMasterSheet_args:
16068 
  """
16069 
  Attributes:
16070 
   - category
16071 
   - brand
16072 
  """
16073 
 
16074 
  thrift_spec = (
16075 
    None, # 0
16076 
    (1, TType.STRING, 'category', None, None, ), # 1
16077 
    (2, TType.STRING, 'brand', None, None, ), # 2
16078 
  )
16079 
 
16080 
  def __init__(self, category=None, brand=None,):
16081 
    self.category = category
16082 
    self.brand = brand
16083 
 
16084 
  def read(self, iprot):
16085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16087 
      return
16088 
    iprot.readStructBegin()
16089 
    while True:
16090 
      (fname, ftype, fid) = iprot.readFieldBegin()
16091 
      if ftype == TType.STOP:
16092 
        break
16093 
      if fid == 1:
16094 
        if ftype == TType.STRING:
16095 
          self.category = iprot.readString();
16096 
        else:
16097 
          iprot.skip(ftype)
16098 
      elif fid == 2:
16099 
        if ftype == TType.STRING:
16100 
          self.brand = iprot.readString();
16101 
        else:
16102 
          iprot.skip(ftype)
16103 
      else:
16104 
        iprot.skip(ftype)
16105 
      iprot.readFieldEnd()
16106 
    iprot.readStructEnd()
16107 
 
16108 
  def write(self, oprot):
16109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16111 
      return
16112 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
16113 
    if self.category is not None:
16114 
      oprot.writeFieldBegin('category', TType.STRING, 1)
16115 
      oprot.writeString(self.category)
16116 
      oprot.writeFieldEnd()
16117 
    if self.brand is not None:
16118 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
16119 
      oprot.writeString(self.brand)
16120 
      oprot.writeFieldEnd()
16121 
    oprot.writeFieldStop()
16122 
    oprot.writeStructEnd()
16123 
 
16124 
  def validate(self):
16125 
    return
16126 
 
16127 
 
16128 
  def __repr__(self):
16129 
    L = ['%s=%r' % (key, value)
16130 
      for key, value in self.__dict__.iteritems()]
16131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16132 
 
16133 
  def __eq__(self, other):
16134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16135 
 
16136 
  def __ne__(self, other):
16137 
    return not (self == other)
16138 
 
16139 
class getItemsForMasterSheet_result:
16140 
  """
16141 
  Attributes:
16142 
   - success
16143 
  """
16144 
 
16145 
  thrift_spec = (
16146 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16147 
  )
16148 
 
16149 
  def __init__(self, success=None,):
16150 
    self.success = success
16151 
 
16152 
  def read(self, iprot):
16153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16155 
      return
16156 
    iprot.readStructBegin()
16157 
    while True:
16158 
      (fname, ftype, fid) = iprot.readFieldBegin()
16159 
      if ftype == TType.STOP:
16160 
        break
16161 
      if fid == 0:
16162 
        if ftype == TType.LIST:
16163 
          self.success = []
9155 kshitij.so 16164 
          (_etype286, _size283) = iprot.readListBegin()
16165 
          for _i287 in xrange(_size283):
16166 
            _elem288 = Item()
16167 
            _elem288.read(iprot)
16168 
            self.success.append(_elem288)
5944 mandeep.dh 16169 
          iprot.readListEnd()
16170 
        else:
16171 
          iprot.skip(ftype)
16172 
      else:
16173 
        iprot.skip(ftype)
16174 
      iprot.readFieldEnd()
16175 
    iprot.readStructEnd()
16176 
 
16177 
  def write(self, oprot):
16178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16180 
      return
16181 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
16182 
    if self.success is not None:
16183 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16184 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16185 
      for iter289 in self.success:
16186 
        iter289.write(oprot)
5944 mandeep.dh 16187 
      oprot.writeListEnd()
16188 
      oprot.writeFieldEnd()
16189 
    oprot.writeFieldStop()
16190 
    oprot.writeStructEnd()
16191 
 
16192 
  def validate(self):
16193 
    return
16194 
 
16195 
 
16196 
  def __repr__(self):
16197 
    L = ['%s=%r' % (key, value)
16198 
      for key, value in self.__dict__.iteritems()]
16199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16200 
 
16201 
  def __eq__(self, other):
16202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16203 
 
16204 
  def __ne__(self, other):
16205 
    return not (self == other)
16206 
 
16207 
class getSimilarItemsCatalogIds_args:
16208 
  """
16209 
  Attributes:
16210 
   - beginIndex
16211 
   - totalItems
16212 
   - itemId
16213 
  """
16214 
 
16215 
  thrift_spec = (
16216 
    None, # 0
16217 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
16218 
    (2, TType.I64, 'totalItems', None, None, ), # 2
16219 
    (3, TType.I64, 'itemId', None, None, ), # 3
16220 
  )
16221 
 
16222 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
16223 
    self.beginIndex = beginIndex
16224 
    self.totalItems = totalItems
16225 
    self.itemId = itemId
16226 
 
16227 
  def read(self, iprot):
16228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16230 
      return
16231 
    iprot.readStructBegin()
16232 
    while True:
16233 
      (fname, ftype, fid) = iprot.readFieldBegin()
16234 
      if ftype == TType.STOP:
16235 
        break
16236 
      if fid == 1:
16237 
        if ftype == TType.I64:
16238 
          self.beginIndex = iprot.readI64();
16239 
        else:
16240 
          iprot.skip(ftype)
16241 
      elif fid == 2:
16242 
        if ftype == TType.I64:
16243 
          self.totalItems = iprot.readI64();
16244 
        else:
16245 
          iprot.skip(ftype)
16246 
      elif fid == 3:
16247 
        if ftype == TType.I64:
16248 
          self.itemId = iprot.readI64();
16249 
        else:
16250 
          iprot.skip(ftype)
16251 
      else:
16252 
        iprot.skip(ftype)
16253 
      iprot.readFieldEnd()
16254 
    iprot.readStructEnd()
16255 
 
16256 
  def write(self, oprot):
16257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16259 
      return
16260 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
16261 
    if self.beginIndex is not None:
16262 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
16263 
      oprot.writeI64(self.beginIndex)
16264 
      oprot.writeFieldEnd()
16265 
    if self.totalItems is not None:
16266 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
16267 
      oprot.writeI64(self.totalItems)
16268 
      oprot.writeFieldEnd()
16269 
    if self.itemId is not None:
16270 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
16271 
      oprot.writeI64(self.itemId)
16272 
      oprot.writeFieldEnd()
16273 
    oprot.writeFieldStop()
16274 
    oprot.writeStructEnd()
16275 
 
16276 
  def validate(self):
16277 
    return
16278 
 
16279 
 
16280 
  def __repr__(self):
16281 
    L = ['%s=%r' % (key, value)
16282 
      for key, value in self.__dict__.iteritems()]
16283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16284 
 
16285 
  def __eq__(self, other):
16286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16287 
 
16288 
  def __ne__(self, other):
16289 
    return not (self == other)
16290 
 
16291 
class getSimilarItemsCatalogIds_result:
16292 
  """
16293 
  Attributes:
16294 
   - success
16295 
  """
16296 
 
16297 
  thrift_spec = (
16298 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
16299 
  )
16300 
 
16301 
  def __init__(self, success=None,):
16302 
    self.success = success
16303 
 
16304 
  def read(self, iprot):
16305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16307 
      return
16308 
    iprot.readStructBegin()
16309 
    while True:
16310 
      (fname, ftype, fid) = iprot.readFieldBegin()
16311 
      if ftype == TType.STOP:
16312 
        break
16313 
      if fid == 0:
16314 
        if ftype == TType.LIST:
16315 
          self.success = []
9155 kshitij.so 16316 
          (_etype293, _size290) = iprot.readListBegin()
16317 
          for _i294 in xrange(_size290):
16318 
            _elem295 = iprot.readI64();
16319 
            self.success.append(_elem295)
5944 mandeep.dh 16320 
          iprot.readListEnd()
16321 
        else:
16322 
          iprot.skip(ftype)
16323 
      else:
16324 
        iprot.skip(ftype)
16325 
      iprot.readFieldEnd()
16326 
    iprot.readStructEnd()
16327 
 
16328 
  def write(self, oprot):
16329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16331 
      return
16332 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
16333 
    if self.success is not None:
16334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16335 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 16336 
      for iter296 in self.success:
16337 
        oprot.writeI64(iter296)
5944 mandeep.dh 16338 
      oprot.writeListEnd()
16339 
      oprot.writeFieldEnd()
16340 
    oprot.writeFieldStop()
16341 
    oprot.writeStructEnd()
16342 
 
16343 
  def validate(self):
16344 
    return
16345 
 
16346 
 
16347 
  def __repr__(self):
16348 
    L = ['%s=%r' % (key, value)
16349 
      for key, value in self.__dict__.iteritems()]
16350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16351 
 
16352 
  def __eq__(self, other):
16353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16354 
 
16355 
  def __ne__(self, other):
16356 
    return not (self == other)
16357 
 
16358 
class addProductNotification_args:
16359 
  """
16360 
  Attributes:
16361 
   - itemId
16362 
   - email
16363 
  """
16364 
 
16365 
  thrift_spec = None
16366 
  def __init__(self, itemId=None, email=None,):
16367 
    self.itemId = itemId
16368 
    self.email = email
16369 
 
16370 
  def read(self, iprot):
16371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16373 
      return
16374 
    iprot.readStructBegin()
16375 
    while True:
16376 
      (fname, ftype, fid) = iprot.readFieldBegin()
16377 
      if ftype == TType.STOP:
16378 
        break
16379 
      if fid == -1:
16380 
        if ftype == TType.I64:
16381 
          self.itemId = iprot.readI64();
16382 
        else:
16383 
          iprot.skip(ftype)
16384 
      elif fid == -2:
16385 
        if ftype == TType.STRING:
16386 
          self.email = iprot.readString();
16387 
        else:
16388 
          iprot.skip(ftype)
16389 
      else:
16390 
        iprot.skip(ftype)
16391 
      iprot.readFieldEnd()
16392 
    iprot.readStructEnd()
16393 
 
16394 
  def write(self, oprot):
16395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16397 
      return
16398 
    oprot.writeStructBegin('addProductNotification_args')
16399 
    if self.email is not None:
16400 
      oprot.writeFieldBegin('email', TType.STRING, -2)
16401 
      oprot.writeString(self.email)
16402 
      oprot.writeFieldEnd()
16403 
    if self.itemId is not None:
16404 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
16405 
      oprot.writeI64(self.itemId)
16406 
      oprot.writeFieldEnd()
16407 
    oprot.writeFieldStop()
16408 
    oprot.writeStructEnd()
16409 
 
16410 
  def validate(self):
16411 
    return
16412 
 
16413 
 
16414 
  def __repr__(self):
16415 
    L = ['%s=%r' % (key, value)
16416 
      for key, value in self.__dict__.iteritems()]
16417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16418 
 
16419 
  def __eq__(self, other):
16420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16421 
 
16422 
  def __ne__(self, other):
16423 
    return not (self == other)
16424 
 
16425 
class addProductNotification_result:
16426 
  """
16427 
  Attributes:
16428 
   - success
16429 
  """
16430 
 
16431 
  thrift_spec = (
16432 
    (0, TType.BOOL, 'success', None, None, ), # 0
16433 
  )
16434 
 
16435 
  def __init__(self, success=None,):
16436 
    self.success = success
16437 
 
16438 
  def read(self, iprot):
16439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16441 
      return
16442 
    iprot.readStructBegin()
16443 
    while True:
16444 
      (fname, ftype, fid) = iprot.readFieldBegin()
16445 
      if ftype == TType.STOP:
16446 
        break
16447 
      if fid == 0:
16448 
        if ftype == TType.BOOL:
16449 
          self.success = iprot.readBool();
16450 
        else:
16451 
          iprot.skip(ftype)
16452 
      else:
16453 
        iprot.skip(ftype)
16454 
      iprot.readFieldEnd()
16455 
    iprot.readStructEnd()
16456 
 
16457 
  def write(self, oprot):
16458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16460 
      return
16461 
    oprot.writeStructBegin('addProductNotification_result')
16462 
    if self.success is not None:
16463 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16464 
      oprot.writeBool(self.success)
16465 
      oprot.writeFieldEnd()
16466 
    oprot.writeFieldStop()
16467 
    oprot.writeStructEnd()
16468 
 
16469 
  def validate(self):
16470 
    return
16471 
 
16472 
 
16473 
  def __repr__(self):
16474 
    L = ['%s=%r' % (key, value)
16475 
      for key, value in self.__dict__.iteritems()]
16476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16477 
 
16478 
  def __eq__(self, other):
16479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16480 
 
16481 
  def __ne__(self, other):
16482 
    return not (self == other)
16483 
 
16484 
class sendProductNotifications_args:
16485 
 
16486 
  thrift_spec = (
16487 
  )
16488 
 
16489 
  def read(self, iprot):
16490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16492 
      return
16493 
    iprot.readStructBegin()
16494 
    while True:
16495 
      (fname, ftype, fid) = iprot.readFieldBegin()
16496 
      if ftype == TType.STOP:
16497 
        break
16498 
      else:
16499 
        iprot.skip(ftype)
16500 
      iprot.readFieldEnd()
16501 
    iprot.readStructEnd()
16502 
 
16503 
  def write(self, oprot):
16504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16506 
      return
16507 
    oprot.writeStructBegin('sendProductNotifications_args')
16508 
    oprot.writeFieldStop()
16509 
    oprot.writeStructEnd()
16510 
 
16511 
  def validate(self):
16512 
    return
16513 
 
16514 
 
16515 
  def __repr__(self):
16516 
    L = ['%s=%r' % (key, value)
16517 
      for key, value in self.__dict__.iteritems()]
16518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16519 
 
16520 
  def __eq__(self, other):
16521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16522 
 
16523 
  def __ne__(self, other):
16524 
    return not (self == other)
16525 
 
16526 
class sendProductNotifications_result:
16527 
  """
16528 
  Attributes:
16529 
   - success
16530 
  """
16531 
 
16532 
  thrift_spec = (
16533 
    (0, TType.BOOL, 'success', None, None, ), # 0
16534 
  )
16535 
 
16536 
  def __init__(self, success=None,):
16537 
    self.success = success
16538 
 
16539 
  def read(self, iprot):
16540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16542 
      return
16543 
    iprot.readStructBegin()
16544 
    while True:
16545 
      (fname, ftype, fid) = iprot.readFieldBegin()
16546 
      if ftype == TType.STOP:
16547 
        break
16548 
      if fid == 0:
16549 
        if ftype == TType.BOOL:
16550 
          self.success = iprot.readBool();
16551 
        else:
16552 
          iprot.skip(ftype)
16553 
      else:
16554 
        iprot.skip(ftype)
16555 
      iprot.readFieldEnd()
16556 
    iprot.readStructEnd()
16557 
 
16558 
  def write(self, oprot):
16559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16561 
      return
16562 
    oprot.writeStructBegin('sendProductNotifications_result')
16563 
    if self.success is not None:
16564 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16565 
      oprot.writeBool(self.success)
16566 
      oprot.writeFieldEnd()
16567 
    oprot.writeFieldStop()
16568 
    oprot.writeStructEnd()
16569 
 
16570 
  def validate(self):
16571 
    return
16572 
 
16573 
 
16574 
  def __repr__(self):
16575 
    L = ['%s=%r' % (key, value)
16576 
      for key, value in self.__dict__.iteritems()]
16577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16578 
 
16579 
  def __eq__(self, other):
16580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16581 
 
16582 
  def __ne__(self, other):
16583 
    return not (self == other)
16584 
 
16585 
class getAllBrandsByCategory_args:
16586 
  """
16587 
  Attributes:
16588 
   - categoryId
16589 
  """
16590 
 
16591 
  thrift_spec = (
16592 
    None, # 0
16593 
    (1, TType.I64, 'categoryId', None, None, ), # 1
16594 
  )
16595 
 
16596 
  def __init__(self, categoryId=None,):
16597 
    self.categoryId = categoryId
16598 
 
16599 
  def read(self, iprot):
16600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16602 
      return
16603 
    iprot.readStructBegin()
16604 
    while True:
16605 
      (fname, ftype, fid) = iprot.readFieldBegin()
16606 
      if ftype == TType.STOP:
16607 
        break
16608 
      if fid == 1:
16609 
        if ftype == TType.I64:
16610 
          self.categoryId = iprot.readI64();
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('getAllBrandsByCategory_args')
16623 
    if self.categoryId is not None:
16624 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
16625 
      oprot.writeI64(self.categoryId)
16626 
      oprot.writeFieldEnd()
16627 
    oprot.writeFieldStop()
16628 
    oprot.writeStructEnd()
16629 
 
16630 
  def validate(self):
16631 
    return
16632 
 
16633 
 
16634 
  def __repr__(self):
16635 
    L = ['%s=%r' % (key, value)
16636 
      for key, value in self.__dict__.iteritems()]
16637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16638 
 
16639 
  def __eq__(self, other):
16640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16641 
 
16642 
  def __ne__(self, other):
16643 
    return not (self == other)
16644 
 
16645 
class getAllBrandsByCategory_result:
16646 
  """
16647 
  Attributes:
16648 
   - success
16649 
  """
16650 
 
16651 
  thrift_spec = (
16652 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16653 
  )
16654 
 
16655 
  def __init__(self, success=None,):
16656 
    self.success = success
16657 
 
16658 
  def read(self, iprot):
16659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16661 
      return
16662 
    iprot.readStructBegin()
16663 
    while True:
16664 
      (fname, ftype, fid) = iprot.readFieldBegin()
16665 
      if ftype == TType.STOP:
16666 
        break
16667 
      if fid == 0:
16668 
        if ftype == TType.LIST:
16669 
          self.success = []
9155 kshitij.so 16670 
          (_etype300, _size297) = iprot.readListBegin()
16671 
          for _i301 in xrange(_size297):
16672 
            _elem302 = iprot.readString();
16673 
            self.success.append(_elem302)
5944 mandeep.dh 16674 
          iprot.readListEnd()
16675 
        else:
16676 
          iprot.skip(ftype)
16677 
      else:
16678 
        iprot.skip(ftype)
16679 
      iprot.readFieldEnd()
16680 
    iprot.readStructEnd()
16681 
 
16682 
  def write(self, oprot):
16683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16685 
      return
16686 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
16687 
    if self.success is not None:
16688 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16689 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16690 
      for iter303 in self.success:
16691 
        oprot.writeString(iter303)
5944 mandeep.dh 16692 
      oprot.writeListEnd()
16693 
      oprot.writeFieldEnd()
16694 
    oprot.writeFieldStop()
16695 
    oprot.writeStructEnd()
16696 
 
16697 
  def validate(self):
16698 
    return
16699 
 
16700 
 
16701 
  def __repr__(self):
16702 
    L = ['%s=%r' % (key, value)
16703 
      for key, value in self.__dict__.iteritems()]
16704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16705 
 
16706 
  def __eq__(self, other):
16707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16708 
 
16709 
  def __ne__(self, other):
16710 
    return not (self == other)
16711 
 
16712 
class getAllBrands_args:
16713 
 
16714 
  thrift_spec = (
16715 
  )
16716 
 
16717 
  def read(self, iprot):
16718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16720 
      return
16721 
    iprot.readStructBegin()
16722 
    while True:
16723 
      (fname, ftype, fid) = iprot.readFieldBegin()
16724 
      if ftype == TType.STOP:
16725 
        break
16726 
      else:
16727 
        iprot.skip(ftype)
16728 
      iprot.readFieldEnd()
16729 
    iprot.readStructEnd()
16730 
 
16731 
  def write(self, oprot):
16732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16734 
      return
16735 
    oprot.writeStructBegin('getAllBrands_args')
16736 
    oprot.writeFieldStop()
16737 
    oprot.writeStructEnd()
16738 
 
16739 
  def validate(self):
16740 
    return
16741 
 
16742 
 
16743 
  def __repr__(self):
16744 
    L = ['%s=%r' % (key, value)
16745 
      for key, value in self.__dict__.iteritems()]
16746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16747 
 
16748 
  def __eq__(self, other):
16749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16750 
 
16751 
  def __ne__(self, other):
16752 
    return not (self == other)
16753 
 
16754 
class getAllBrands_result:
16755 
  """
16756 
  Attributes:
16757 
   - success
16758 
  """
16759 
 
16760 
  thrift_spec = (
16761 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16762 
  )
16763 
 
16764 
  def __init__(self, success=None,):
16765 
    self.success = success
16766 
 
16767 
  def read(self, iprot):
16768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16770 
      return
16771 
    iprot.readStructBegin()
16772 
    while True:
16773 
      (fname, ftype, fid) = iprot.readFieldBegin()
16774 
      if ftype == TType.STOP:
16775 
        break
16776 
      if fid == 0:
16777 
        if ftype == TType.LIST:
16778 
          self.success = []
9155 kshitij.so 16779 
          (_etype307, _size304) = iprot.readListBegin()
16780 
          for _i308 in xrange(_size304):
16781 
            _elem309 = iprot.readString();
16782 
            self.success.append(_elem309)
5944 mandeep.dh 16783 
          iprot.readListEnd()
16784 
        else:
16785 
          iprot.skip(ftype)
16786 
      else:
16787 
        iprot.skip(ftype)
16788 
      iprot.readFieldEnd()
16789 
    iprot.readStructEnd()
16790 
 
16791 
  def write(self, oprot):
16792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16794 
      return
16795 
    oprot.writeStructBegin('getAllBrands_result')
16796 
    if self.success is not None:
16797 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16798 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16799 
      for iter310 in self.success:
16800 
        oprot.writeString(iter310)
5944 mandeep.dh 16801 
      oprot.writeListEnd()
16802 
      oprot.writeFieldEnd()
16803 
    oprot.writeFieldStop()
16804 
    oprot.writeStructEnd()
16805 
 
16806 
  def validate(self):
16807 
    return
16808 
 
16809 
 
16810 
  def __repr__(self):
16811 
    L = ['%s=%r' % (key, value)
16812 
      for key, value in self.__dict__.iteritems()]
16813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16814 
 
16815 
  def __eq__(self, other):
16816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16817 
 
16818 
  def __ne__(self, other):
16819 
    return not (self == other)
16820 
 
16821 
class getAllSources_args:
16822 
 
16823 
  thrift_spec = (
16824 
  )
16825 
 
16826 
  def read(self, iprot):
16827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16829 
      return
16830 
    iprot.readStructBegin()
16831 
    while True:
16832 
      (fname, ftype, fid) = iprot.readFieldBegin()
16833 
      if ftype == TType.STOP:
16834 
        break
16835 
      else:
16836 
        iprot.skip(ftype)
16837 
      iprot.readFieldEnd()
16838 
    iprot.readStructEnd()
16839 
 
16840 
  def write(self, oprot):
16841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16843 
      return
16844 
    oprot.writeStructBegin('getAllSources_args')
16845 
    oprot.writeFieldStop()
16846 
    oprot.writeStructEnd()
16847 
 
16848 
  def validate(self):
16849 
    return
16850 
 
16851 
 
16852 
  def __repr__(self):
16853 
    L = ['%s=%r' % (key, value)
16854 
      for key, value in self.__dict__.iteritems()]
16855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16856 
 
16857 
  def __eq__(self, other):
16858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16859 
 
16860 
  def __ne__(self, other):
16861 
    return not (self == other)
16862 
 
16863 
class getAllSources_result:
16864 
  """
16865 
  Attributes:
16866 
   - success
16867 
  """
16868 
 
16869 
  thrift_spec = (
16870 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
16871 
  )
16872 
 
16873 
  def __init__(self, success=None,):
16874 
    self.success = success
16875 
 
16876 
  def read(self, iprot):
16877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16879 
      return
16880 
    iprot.readStructBegin()
16881 
    while True:
16882 
      (fname, ftype, fid) = iprot.readFieldBegin()
16883 
      if ftype == TType.STOP:
16884 
        break
16885 
      if fid == 0:
16886 
        if ftype == TType.LIST:
16887 
          self.success = []
9155 kshitij.so 16888 
          (_etype314, _size311) = iprot.readListBegin()
16889 
          for _i315 in xrange(_size311):
16890 
            _elem316 = Source()
16891 
            _elem316.read(iprot)
16892 
            self.success.append(_elem316)
5944 mandeep.dh 16893 
          iprot.readListEnd()
16894 
        else:
16895 
          iprot.skip(ftype)
16896 
      else:
16897 
        iprot.skip(ftype)
16898 
      iprot.readFieldEnd()
16899 
    iprot.readStructEnd()
16900 
 
16901 
  def write(self, oprot):
16902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16904 
      return
16905 
    oprot.writeStructBegin('getAllSources_result')
16906 
    if self.success is not None:
16907 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16908 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16909 
      for iter317 in self.success:
16910 
        iter317.write(oprot)
5944 mandeep.dh 16911 
      oprot.writeListEnd()
16912 
      oprot.writeFieldEnd()
16913 
    oprot.writeFieldStop()
16914 
    oprot.writeStructEnd()
16915 
 
16916 
  def validate(self):
16917 
    return
16918 
 
16919 
 
16920 
  def __repr__(self):
16921 
    L = ['%s=%r' % (key, value)
16922 
      for key, value in self.__dict__.iteritems()]
16923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16924 
 
16925 
  def __eq__(self, other):
16926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16927 
 
16928 
  def __ne__(self, other):
16929 
    return not (self == other)
16930 
 
16931 
class getItemPricingBySource_args:
16932 
  """
16933 
  Attributes:
16934 
   - itemId
16935 
   - sourceId
16936 
  """
16937 
 
16938 
  thrift_spec = (
16939 
    None, # 0
16940 
    (1, TType.I64, 'itemId', None, None, ), # 1
16941 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16942 
  )
16943 
 
16944 
  def __init__(self, itemId=None, sourceId=None,):
16945 
    self.itemId = itemId
16946 
    self.sourceId = sourceId
16947 
 
16948 
  def read(self, iprot):
16949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16951 
      return
16952 
    iprot.readStructBegin()
16953 
    while True:
16954 
      (fname, ftype, fid) = iprot.readFieldBegin()
16955 
      if ftype == TType.STOP:
16956 
        break
16957 
      if fid == 1:
16958 
        if ftype == TType.I64:
16959 
          self.itemId = iprot.readI64();
16960 
        else:
16961 
          iprot.skip(ftype)
16962 
      elif fid == 2:
16963 
        if ftype == TType.I64:
16964 
          self.sourceId = iprot.readI64();
16965 
        else:
16966 
          iprot.skip(ftype)
16967 
      else:
16968 
        iprot.skip(ftype)
16969 
      iprot.readFieldEnd()
16970 
    iprot.readStructEnd()
16971 
 
16972 
  def write(self, oprot):
16973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16975 
      return
16976 
    oprot.writeStructBegin('getItemPricingBySource_args')
16977 
    if self.itemId is not None:
16978 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16979 
      oprot.writeI64(self.itemId)
16980 
      oprot.writeFieldEnd()
16981 
    if self.sourceId is not None:
16982 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16983 
      oprot.writeI64(self.sourceId)
16984 
      oprot.writeFieldEnd()
16985 
    oprot.writeFieldStop()
16986 
    oprot.writeStructEnd()
16987 
 
16988 
  def validate(self):
16989 
    return
16990 
 
16991 
 
16992 
  def __repr__(self):
16993 
    L = ['%s=%r' % (key, value)
16994 
      for key, value in self.__dict__.iteritems()]
16995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16996 
 
16997 
  def __eq__(self, other):
16998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16999 
 
17000 
  def __ne__(self, other):
17001 
    return not (self == other)
17002 
 
17003 
class getItemPricingBySource_result:
17004 
  """
17005 
  Attributes:
17006 
   - success
17007 
   - cex
17008 
  """
17009 
 
17010 
  thrift_spec = (
17011 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
17012 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17013 
  )
17014 
 
17015 
  def __init__(self, success=None, cex=None,):
17016 
    self.success = success
17017 
    self.cex = cex
17018 
 
17019 
  def read(self, iprot):
17020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17022 
      return
17023 
    iprot.readStructBegin()
17024 
    while True:
17025 
      (fname, ftype, fid) = iprot.readFieldBegin()
17026 
      if ftype == TType.STOP:
17027 
        break
17028 
      if fid == 0:
17029 
        if ftype == TType.STRUCT:
17030 
          self.success = SourceItemPricing()
17031 
          self.success.read(iprot)
17032 
        else:
17033 
          iprot.skip(ftype)
17034 
      elif fid == 1:
17035 
        if ftype == TType.STRUCT:
17036 
          self.cex = CatalogServiceException()
17037 
          self.cex.read(iprot)
17038 
        else:
17039 
          iprot.skip(ftype)
17040 
      else:
17041 
        iprot.skip(ftype)
17042 
      iprot.readFieldEnd()
17043 
    iprot.readStructEnd()
17044 
 
17045 
  def write(self, oprot):
17046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17048 
      return
17049 
    oprot.writeStructBegin('getItemPricingBySource_result')
17050 
    if self.success is not None:
17051 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17052 
      self.success.write(oprot)
17053 
      oprot.writeFieldEnd()
17054 
    if self.cex is not None:
17055 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17056 
      self.cex.write(oprot)
17057 
      oprot.writeFieldEnd()
17058 
    oprot.writeFieldStop()
17059 
    oprot.writeStructEnd()
17060 
 
17061 
  def validate(self):
17062 
    return
17063 
 
17064 
 
17065 
  def __repr__(self):
17066 
    L = ['%s=%r' % (key, value)
17067 
      for key, value in self.__dict__.iteritems()]
17068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17069 
 
17070 
  def __eq__(self, other):
17071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17072 
 
17073 
  def __ne__(self, other):
17074 
    return not (self == other)
17075 
 
17076 
class addSourceItemPricing_args:
17077 
  """
17078 
  Attributes:
17079 
   - sourceItemPricing
17080 
  """
17081 
 
17082 
  thrift_spec = (
17083 
    None, # 0
17084 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
17085 
  )
17086 
 
17087 
  def __init__(self, sourceItemPricing=None,):
17088 
    self.sourceItemPricing = sourceItemPricing
17089 
 
17090 
  def read(self, iprot):
17091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17093 
      return
17094 
    iprot.readStructBegin()
17095 
    while True:
17096 
      (fname, ftype, fid) = iprot.readFieldBegin()
17097 
      if ftype == TType.STOP:
17098 
        break
17099 
      if fid == 1:
17100 
        if ftype == TType.STRUCT:
17101 
          self.sourceItemPricing = SourceItemPricing()
17102 
          self.sourceItemPricing.read(iprot)
17103 
        else:
17104 
          iprot.skip(ftype)
17105 
      else:
17106 
        iprot.skip(ftype)
17107 
      iprot.readFieldEnd()
17108 
    iprot.readStructEnd()
17109 
 
17110 
  def write(self, oprot):
17111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17113 
      return
17114 
    oprot.writeStructBegin('addSourceItemPricing_args')
17115 
    if self.sourceItemPricing is not None:
17116 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
17117 
      self.sourceItemPricing.write(oprot)
17118 
      oprot.writeFieldEnd()
17119 
    oprot.writeFieldStop()
17120 
    oprot.writeStructEnd()
17121 
 
17122 
  def validate(self):
17123 
    return
17124 
 
17125 
 
17126 
  def __repr__(self):
17127 
    L = ['%s=%r' % (key, value)
17128 
      for key, value in self.__dict__.iteritems()]
17129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17130 
 
17131 
  def __eq__(self, other):
17132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17133 
 
17134 
  def __ne__(self, other):
17135 
    return not (self == other)
17136 
 
17137 
class addSourceItemPricing_result:
17138 
  """
17139 
  Attributes:
17140 
   - cex
17141 
  """
17142 
 
17143 
  thrift_spec = (
17144 
    None, # 0
17145 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17146 
  )
17147 
 
17148 
  def __init__(self, cex=None,):
17149 
    self.cex = cex
17150 
 
17151 
  def read(self, iprot):
17152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17154 
      return
17155 
    iprot.readStructBegin()
17156 
    while True:
17157 
      (fname, ftype, fid) = iprot.readFieldBegin()
17158 
      if ftype == TType.STOP:
17159 
        break
17160 
      if fid == 1:
17161 
        if ftype == TType.STRUCT:
17162 
          self.cex = CatalogServiceException()
17163 
          self.cex.read(iprot)
17164 
        else:
17165 
          iprot.skip(ftype)
17166 
      else:
17167 
        iprot.skip(ftype)
17168 
      iprot.readFieldEnd()
17169 
    iprot.readStructEnd()
17170 
 
17171 
  def write(self, oprot):
17172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17174 
      return
17175 
    oprot.writeStructBegin('addSourceItemPricing_result')
17176 
    if self.cex is not None:
17177 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17178 
      self.cex.write(oprot)
17179 
      oprot.writeFieldEnd()
17180 
    oprot.writeFieldStop()
17181 
    oprot.writeStructEnd()
17182 
 
17183 
  def validate(self):
17184 
    return
17185 
 
17186 
 
17187 
  def __repr__(self):
17188 
    L = ['%s=%r' % (key, value)
17189 
      for key, value in self.__dict__.iteritems()]
17190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17191 
 
17192 
  def __eq__(self, other):
17193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17194 
 
17195 
  def __ne__(self, other):
17196 
    return not (self == other)
17197 
 
17198 
class getAllSourcePricing_args:
17199 
  """
17200 
  Attributes:
17201 
   - itemId
17202 
  """
17203 
 
17204 
  thrift_spec = (
17205 
    None, # 0
17206 
    (1, TType.I64, 'itemId', None, None, ), # 1
17207 
  )
17208 
 
17209 
  def __init__(self, itemId=None,):
17210 
    self.itemId = itemId
17211 
 
17212 
  def read(self, iprot):
17213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17215 
      return
17216 
    iprot.readStructBegin()
17217 
    while True:
17218 
      (fname, ftype, fid) = iprot.readFieldBegin()
17219 
      if ftype == TType.STOP:
17220 
        break
17221 
      if fid == 1:
17222 
        if ftype == TType.I64:
17223 
          self.itemId = iprot.readI64();
17224 
        else:
17225 
          iprot.skip(ftype)
17226 
      else:
17227 
        iprot.skip(ftype)
17228 
      iprot.readFieldEnd()
17229 
    iprot.readStructEnd()
17230 
 
17231 
  def write(self, oprot):
17232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17234 
      return
17235 
    oprot.writeStructBegin('getAllSourcePricing_args')
17236 
    if self.itemId is not None:
17237 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17238 
      oprot.writeI64(self.itemId)
17239 
      oprot.writeFieldEnd()
17240 
    oprot.writeFieldStop()
17241 
    oprot.writeStructEnd()
17242 
 
17243 
  def validate(self):
17244 
    return
17245 
 
17246 
 
17247 
  def __repr__(self):
17248 
    L = ['%s=%r' % (key, value)
17249 
      for key, value in self.__dict__.iteritems()]
17250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17251 
 
17252 
  def __eq__(self, other):
17253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17254 
 
17255 
  def __ne__(self, other):
17256 
    return not (self == other)
17257 
 
17258 
class getAllSourcePricing_result:
17259 
  """
17260 
  Attributes:
17261 
   - success
17262 
   - cex
17263 
  """
17264 
 
17265 
  thrift_spec = (
17266 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
17267 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17268 
  )
17269 
 
17270 
  def __init__(self, success=None, cex=None,):
17271 
    self.success = success
17272 
    self.cex = cex
17273 
 
17274 
  def read(self, iprot):
17275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17277 
      return
17278 
    iprot.readStructBegin()
17279 
    while True:
17280 
      (fname, ftype, fid) = iprot.readFieldBegin()
17281 
      if ftype == TType.STOP:
17282 
        break
17283 
      if fid == 0:
17284 
        if ftype == TType.LIST:
17285 
          self.success = []
9155 kshitij.so 17286 
          (_etype321, _size318) = iprot.readListBegin()
17287 
          for _i322 in xrange(_size318):
17288 
            _elem323 = SourceItemPricing()
17289 
            _elem323.read(iprot)
17290 
            self.success.append(_elem323)
5944 mandeep.dh 17291 
          iprot.readListEnd()
17292 
        else:
17293 
          iprot.skip(ftype)
17294 
      elif fid == 1:
17295 
        if ftype == TType.STRUCT:
17296 
          self.cex = CatalogServiceException()
17297 
          self.cex.read(iprot)
17298 
        else:
17299 
          iprot.skip(ftype)
17300 
      else:
17301 
        iprot.skip(ftype)
17302 
      iprot.readFieldEnd()
17303 
    iprot.readStructEnd()
17304 
 
17305 
  def write(self, oprot):
17306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17308 
      return
17309 
    oprot.writeStructBegin('getAllSourcePricing_result')
17310 
    if self.success is not None:
17311 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17312 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17313 
      for iter324 in self.success:
17314 
        iter324.write(oprot)
5944 mandeep.dh 17315 
      oprot.writeListEnd()
17316 
      oprot.writeFieldEnd()
17317 
    if self.cex is not None:
17318 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17319 
      self.cex.write(oprot)
17320 
      oprot.writeFieldEnd()
17321 
    oprot.writeFieldStop()
17322 
    oprot.writeStructEnd()
17323 
 
17324 
  def validate(self):
17325 
    return
17326 
 
17327 
 
17328 
  def __repr__(self):
17329 
    L = ['%s=%r' % (key, value)
17330 
      for key, value in self.__dict__.iteritems()]
17331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17332 
 
17333 
  def __eq__(self, other):
17334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17335 
 
17336 
  def __ne__(self, other):
17337 
    return not (self == other)
17338 
 
17339 
class getItemForSource_args:
17340 
  """
17341 
  Attributes:
17342 
   - item_id
17343 
   - sourceId
17344 
  """
17345 
 
17346 
  thrift_spec = (
17347 
    None, # 0
17348 
    (1, TType.I64, 'item_id', None, None, ), # 1
17349 
    (2, TType.I64, 'sourceId', None, None, ), # 2
17350 
  )
17351 
 
17352 
  def __init__(self, item_id=None, sourceId=None,):
17353 
    self.item_id = item_id
17354 
    self.sourceId = sourceId
17355 
 
17356 
  def read(self, iprot):
17357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17359 
      return
17360 
    iprot.readStructBegin()
17361 
    while True:
17362 
      (fname, ftype, fid) = iprot.readFieldBegin()
17363 
      if ftype == TType.STOP:
17364 
        break
17365 
      if fid == 1:
17366 
        if ftype == TType.I64:
17367 
          self.item_id = iprot.readI64();
17368 
        else:
17369 
          iprot.skip(ftype)
17370 
      elif fid == 2:
17371 
        if ftype == TType.I64:
17372 
          self.sourceId = iprot.readI64();
17373 
        else:
17374 
          iprot.skip(ftype)
17375 
      else:
17376 
        iprot.skip(ftype)
17377 
      iprot.readFieldEnd()
17378 
    iprot.readStructEnd()
17379 
 
17380 
  def write(self, oprot):
17381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17383 
      return
17384 
    oprot.writeStructBegin('getItemForSource_args')
17385 
    if self.item_id is not None:
17386 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
17387 
      oprot.writeI64(self.item_id)
17388 
      oprot.writeFieldEnd()
17389 
    if self.sourceId is not None:
17390 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
17391 
      oprot.writeI64(self.sourceId)
17392 
      oprot.writeFieldEnd()
17393 
    oprot.writeFieldStop()
17394 
    oprot.writeStructEnd()
17395 
 
17396 
  def validate(self):
17397 
    return
17398 
 
17399 
 
17400 
  def __repr__(self):
17401 
    L = ['%s=%r' % (key, value)
17402 
      for key, value in self.__dict__.iteritems()]
17403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17404 
 
17405 
  def __eq__(self, other):
17406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17407 
 
17408 
  def __ne__(self, other):
17409 
    return not (self == other)
17410 
 
17411 
class getItemForSource_result:
17412 
  """
17413 
  Attributes:
17414 
   - success
17415 
   - cex
17416 
  """
17417 
 
17418 
  thrift_spec = (
17419 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
17420 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17421 
  )
17422 
 
17423 
  def __init__(self, success=None, cex=None,):
17424 
    self.success = success
17425 
    self.cex = cex
17426 
 
17427 
  def read(self, iprot):
17428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17430 
      return
17431 
    iprot.readStructBegin()
17432 
    while True:
17433 
      (fname, ftype, fid) = iprot.readFieldBegin()
17434 
      if ftype == TType.STOP:
17435 
        break
17436 
      if fid == 0:
17437 
        if ftype == TType.STRUCT:
17438 
          self.success = Item()
17439 
          self.success.read(iprot)
17440 
        else:
17441 
          iprot.skip(ftype)
17442 
      elif fid == 1:
17443 
        if ftype == TType.STRUCT:
17444 
          self.cex = CatalogServiceException()
17445 
          self.cex.read(iprot)
17446 
        else:
17447 
          iprot.skip(ftype)
17448 
      else:
17449 
        iprot.skip(ftype)
17450 
      iprot.readFieldEnd()
17451 
    iprot.readStructEnd()
17452 
 
17453 
  def write(self, oprot):
17454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17456 
      return
17457 
    oprot.writeStructBegin('getItemForSource_result')
17458 
    if self.success is not None:
17459 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17460 
      self.success.write(oprot)
17461 
      oprot.writeFieldEnd()
17462 
    if self.cex is not None:
17463 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17464 
      self.cex.write(oprot)
17465 
      oprot.writeFieldEnd()
17466 
    oprot.writeFieldStop()
17467 
    oprot.writeStructEnd()
17468 
 
17469 
  def validate(self):
17470 
    return
17471 
 
17472 
 
17473 
  def __repr__(self):
17474 
    L = ['%s=%r' % (key, value)
17475 
      for key, value in self.__dict__.iteritems()]
17476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17477 
 
17478 
  def __eq__(self, other):
17479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17480 
 
17481 
  def __ne__(self, other):
17482 
    return not (self == other)
17483 
 
17484 
class searchItemsInRange_args:
17485 
  """
17486 
  Attributes:
17487 
   - searchTerms
17488 
   - offset
17489 
   - limit
17490 
  """
17491 
 
17492 
  thrift_spec = (
17493 
    None, # 0
17494 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17495 
    (2, TType.I64, 'offset', None, None, ), # 2
17496 
    (3, TType.I64, 'limit', None, None, ), # 3
17497 
  )
17498 
 
17499 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
17500 
    self.searchTerms = searchTerms
17501 
    self.offset = offset
17502 
    self.limit = limit
17503 
 
17504 
  def read(self, iprot):
17505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17507 
      return
17508 
    iprot.readStructBegin()
17509 
    while True:
17510 
      (fname, ftype, fid) = iprot.readFieldBegin()
17511 
      if ftype == TType.STOP:
17512 
        break
17513 
      if fid == 1:
17514 
        if ftype == TType.LIST:
17515 
          self.searchTerms = []
9155 kshitij.so 17516 
          (_etype328, _size325) = iprot.readListBegin()
17517 
          for _i329 in xrange(_size325):
17518 
            _elem330 = iprot.readString();
17519 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 17520 
          iprot.readListEnd()
17521 
        else:
17522 
          iprot.skip(ftype)
17523 
      elif fid == 2:
17524 
        if ftype == TType.I64:
17525 
          self.offset = iprot.readI64();
17526 
        else:
17527 
          iprot.skip(ftype)
17528 
      elif fid == 3:
17529 
        if ftype == TType.I64:
17530 
          self.limit = iprot.readI64();
17531 
        else:
17532 
          iprot.skip(ftype)
17533 
      else:
17534 
        iprot.skip(ftype)
17535 
      iprot.readFieldEnd()
17536 
    iprot.readStructEnd()
17537 
 
17538 
  def write(self, oprot):
17539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17541 
      return
17542 
    oprot.writeStructBegin('searchItemsInRange_args')
17543 
    if self.searchTerms is not None:
17544 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17545 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17546 
      for iter331 in self.searchTerms:
17547 
        oprot.writeString(iter331)
5944 mandeep.dh 17548 
      oprot.writeListEnd()
17549 
      oprot.writeFieldEnd()
17550 
    if self.offset is not None:
17551 
      oprot.writeFieldBegin('offset', TType.I64, 2)
17552 
      oprot.writeI64(self.offset)
17553 
      oprot.writeFieldEnd()
17554 
    if self.limit is not None:
17555 
      oprot.writeFieldBegin('limit', TType.I64, 3)
17556 
      oprot.writeI64(self.limit)
17557 
      oprot.writeFieldEnd()
17558 
    oprot.writeFieldStop()
17559 
    oprot.writeStructEnd()
17560 
 
17561 
  def validate(self):
17562 
    return
17563 
 
17564 
 
17565 
  def __repr__(self):
17566 
    L = ['%s=%r' % (key, value)
17567 
      for key, value in self.__dict__.iteritems()]
17568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17569 
 
17570 
  def __eq__(self, other):
17571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17572 
 
17573 
  def __ne__(self, other):
17574 
    return not (self == other)
17575 
 
17576 
class searchItemsInRange_result:
17577 
  """
17578 
  Attributes:
17579 
   - success
17580 
  """
17581 
 
17582 
  thrift_spec = (
17583 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17584 
  )
17585 
 
17586 
  def __init__(self, success=None,):
17587 
    self.success = success
17588 
 
17589 
  def read(self, iprot):
17590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17592 
      return
17593 
    iprot.readStructBegin()
17594 
    while True:
17595 
      (fname, ftype, fid) = iprot.readFieldBegin()
17596 
      if ftype == TType.STOP:
17597 
        break
17598 
      if fid == 0:
17599 
        if ftype == TType.LIST:
17600 
          self.success = []
9155 kshitij.so 17601 
          (_etype335, _size332) = iprot.readListBegin()
17602 
          for _i336 in xrange(_size332):
17603 
            _elem337 = Item()
17604 
            _elem337.read(iprot)
17605 
            self.success.append(_elem337)
5944 mandeep.dh 17606 
          iprot.readListEnd()
17607 
        else:
17608 
          iprot.skip(ftype)
17609 
      else:
17610 
        iprot.skip(ftype)
17611 
      iprot.readFieldEnd()
17612 
    iprot.readStructEnd()
17613 
 
17614 
  def write(self, oprot):
17615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17617 
      return
17618 
    oprot.writeStructBegin('searchItemsInRange_result')
17619 
    if self.success is not None:
17620 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17621 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17622 
      for iter338 in self.success:
17623 
        iter338.write(oprot)
5944 mandeep.dh 17624 
      oprot.writeListEnd()
17625 
      oprot.writeFieldEnd()
17626 
    oprot.writeFieldStop()
17627 
    oprot.writeStructEnd()
17628 
 
17629 
  def validate(self):
17630 
    return
17631 
 
17632 
 
17633 
  def __repr__(self):
17634 
    L = ['%s=%r' % (key, value)
17635 
      for key, value in self.__dict__.iteritems()]
17636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17637 
 
17638 
  def __eq__(self, other):
17639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17640 
 
17641 
  def __ne__(self, other):
17642 
    return not (self == other)
17643 
 
17644 
class getSearchResultCount_args:
17645 
  """
17646 
  Attributes:
17647 
   - searchTerms
17648 
  """
17649 
 
17650 
  thrift_spec = (
17651 
    None, # 0
17652 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17653 
  )
17654 
 
17655 
  def __init__(self, searchTerms=None,):
17656 
    self.searchTerms = searchTerms
17657 
 
17658 
  def read(self, iprot):
17659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17661 
      return
17662 
    iprot.readStructBegin()
17663 
    while True:
17664 
      (fname, ftype, fid) = iprot.readFieldBegin()
17665 
      if ftype == TType.STOP:
17666 
        break
17667 
      if fid == 1:
17668 
        if ftype == TType.LIST:
17669 
          self.searchTerms = []
9155 kshitij.so 17670 
          (_etype342, _size339) = iprot.readListBegin()
17671 
          for _i343 in xrange(_size339):
17672 
            _elem344 = iprot.readString();
17673 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 17674 
          iprot.readListEnd()
17675 
        else:
17676 
          iprot.skip(ftype)
17677 
      else:
17678 
        iprot.skip(ftype)
17679 
      iprot.readFieldEnd()
17680 
    iprot.readStructEnd()
17681 
 
17682 
  def write(self, oprot):
17683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17685 
      return
17686 
    oprot.writeStructBegin('getSearchResultCount_args')
17687 
    if self.searchTerms is not None:
17688 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17689 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17690 
      for iter345 in self.searchTerms:
17691 
        oprot.writeString(iter345)
5944 mandeep.dh 17692 
      oprot.writeListEnd()
17693 
      oprot.writeFieldEnd()
17694 
    oprot.writeFieldStop()
17695 
    oprot.writeStructEnd()
17696 
 
17697 
  def validate(self):
17698 
    return
17699 
 
17700 
 
17701 
  def __repr__(self):
17702 
    L = ['%s=%r' % (key, value)
17703 
      for key, value in self.__dict__.iteritems()]
17704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17705 
 
17706 
  def __eq__(self, other):
17707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17708 
 
17709 
  def __ne__(self, other):
17710 
    return not (self == other)
17711 
 
17712 
class getSearchResultCount_result:
17713 
  """
17714 
  Attributes:
17715 
   - success
17716 
  """
17717 
 
17718 
  thrift_spec = (
17719 
    (0, TType.I32, 'success', None, None, ), # 0
17720 
  )
17721 
 
17722 
  def __init__(self, success=None,):
17723 
    self.success = success
17724 
 
17725 
  def read(self, iprot):
17726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17728 
      return
17729 
    iprot.readStructBegin()
17730 
    while True:
17731 
      (fname, ftype, fid) = iprot.readFieldBegin()
17732 
      if ftype == TType.STOP:
17733 
        break
17734 
      if fid == 0:
17735 
        if ftype == TType.I32:
17736 
          self.success = iprot.readI32();
17737 
        else:
17738 
          iprot.skip(ftype)
17739 
      else:
17740 
        iprot.skip(ftype)
17741 
      iprot.readFieldEnd()
17742 
    iprot.readStructEnd()
17743 
 
17744 
  def write(self, oprot):
17745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17747 
      return
17748 
    oprot.writeStructBegin('getSearchResultCount_result')
17749 
    if self.success is not None:
17750 
      oprot.writeFieldBegin('success', TType.I32, 0)
17751 
      oprot.writeI32(self.success)
17752 
      oprot.writeFieldEnd()
17753 
    oprot.writeFieldStop()
17754 
    oprot.writeStructEnd()
17755 
 
17756 
  def validate(self):
17757 
    return
17758 
 
17759 
 
17760 
  def __repr__(self):
17761 
    L = ['%s=%r' % (key, value)
17762 
      for key, value in self.__dict__.iteritems()]
17763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17764 
 
17765 
  def __eq__(self, other):
17766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17767 
 
17768 
  def __ne__(self, other):
17769 
    return not (self == other)
17770 
 
17771 
class getProductNotifications_args:
17772 
  """
17773 
  Attributes:
17774 
   - startDateTime
17775 
  """
17776 
 
17777 
  thrift_spec = (
17778 
    None, # 0
17779 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
17780 
  )
17781 
 
17782 
  def __init__(self, startDateTime=None,):
17783 
    self.startDateTime = startDateTime
17784 
 
17785 
  def read(self, iprot):
17786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17788 
      return
17789 
    iprot.readStructBegin()
17790 
    while True:
17791 
      (fname, ftype, fid) = iprot.readFieldBegin()
17792 
      if ftype == TType.STOP:
17793 
        break
17794 
      if fid == 1:
17795 
        if ftype == TType.I64:
17796 
          self.startDateTime = iprot.readI64();
17797 
        else:
17798 
          iprot.skip(ftype)
17799 
      else:
17800 
        iprot.skip(ftype)
17801 
      iprot.readFieldEnd()
17802 
    iprot.readStructEnd()
17803 
 
17804 
  def write(self, oprot):
17805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17807 
      return
17808 
    oprot.writeStructBegin('getProductNotifications_args')
17809 
    if self.startDateTime is not None:
17810 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17811 
      oprot.writeI64(self.startDateTime)
17812 
      oprot.writeFieldEnd()
17813 
    oprot.writeFieldStop()
17814 
    oprot.writeStructEnd()
17815 
 
17816 
  def validate(self):
17817 
    return
17818 
 
17819 
 
17820 
  def __repr__(self):
17821 
    L = ['%s=%r' % (key, value)
17822 
      for key, value in self.__dict__.iteritems()]
17823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17824 
 
17825 
  def __eq__(self, other):
17826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17827 
 
17828 
  def __ne__(self, other):
17829 
    return not (self == other)
17830 
 
17831 
class getProductNotifications_result:
17832 
  """
17833 
  Attributes:
17834 
   - success
17835 
  """
17836 
 
17837 
  thrift_spec = (
17838 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
17839 
  )
17840 
 
17841 
  def __init__(self, success=None,):
17842 
    self.success = success
17843 
 
17844 
  def read(self, iprot):
17845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17847 
      return
17848 
    iprot.readStructBegin()
17849 
    while True:
17850 
      (fname, ftype, fid) = iprot.readFieldBegin()
17851 
      if ftype == TType.STOP:
17852 
        break
17853 
      if fid == 0:
17854 
        if ftype == TType.LIST:
17855 
          self.success = []
9155 kshitij.so 17856 
          (_etype349, _size346) = iprot.readListBegin()
17857 
          for _i350 in xrange(_size346):
17858 
            _elem351 = ProductNotificationRequest()
17859 
            _elem351.read(iprot)
17860 
            self.success.append(_elem351)
5944 mandeep.dh 17861 
          iprot.readListEnd()
17862 
        else:
17863 
          iprot.skip(ftype)
17864 
      else:
17865 
        iprot.skip(ftype)
17866 
      iprot.readFieldEnd()
17867 
    iprot.readStructEnd()
17868 
 
17869 
  def write(self, oprot):
17870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17872 
      return
17873 
    oprot.writeStructBegin('getProductNotifications_result')
17874 
    if self.success is not None:
17875 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17876 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17877 
      for iter352 in self.success:
17878 
        iter352.write(oprot)
5944 mandeep.dh 17879 
      oprot.writeListEnd()
17880 
      oprot.writeFieldEnd()
17881 
    oprot.writeFieldStop()
17882 
    oprot.writeStructEnd()
17883 
 
17884 
  def validate(self):
17885 
    return
17886 
 
17887 
 
17888 
  def __repr__(self):
17889 
    L = ['%s=%r' % (key, value)
17890 
      for key, value in self.__dict__.iteritems()]
17891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17892 
 
17893 
  def __eq__(self, other):
17894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17895 
 
17896 
  def __ne__(self, other):
17897 
    return not (self == other)
17898 
 
17899 
class getProductNotificationRequestCount_args:
17900 
  """
17901 
  Attributes:
17902 
   - startDateTime
7897 amar.kumar 17903 
   - categoryId
5944 mandeep.dh 17904 
  """
17905 
 
17906 
  thrift_spec = (
17907 
    None, # 0
17908 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 17909 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 17910 
  )
17911 
 
7897 amar.kumar 17912 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 17913 
    self.startDateTime = startDateTime
7897 amar.kumar 17914 
    self.categoryId = categoryId
5944 mandeep.dh 17915 
 
17916 
  def read(self, iprot):
17917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17919 
      return
17920 
    iprot.readStructBegin()
17921 
    while True:
17922 
      (fname, ftype, fid) = iprot.readFieldBegin()
17923 
      if ftype == TType.STOP:
17924 
        break
17925 
      if fid == 1:
17926 
        if ftype == TType.I64:
17927 
          self.startDateTime = iprot.readI64();
17928 
        else:
17929 
          iprot.skip(ftype)
7897 amar.kumar 17930 
      elif fid == 2:
17931 
        if ftype == TType.I64:
17932 
          self.categoryId = iprot.readI64();
17933 
        else:
17934 
          iprot.skip(ftype)
5944 mandeep.dh 17935 
      else:
17936 
        iprot.skip(ftype)
17937 
      iprot.readFieldEnd()
17938 
    iprot.readStructEnd()
17939 
 
17940 
  def write(self, oprot):
17941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17943 
      return
17944 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
17945 
    if self.startDateTime is not None:
17946 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17947 
      oprot.writeI64(self.startDateTime)
17948 
      oprot.writeFieldEnd()
7897 amar.kumar 17949 
    if self.categoryId is not None:
17950 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
17951 
      oprot.writeI64(self.categoryId)
17952 
      oprot.writeFieldEnd()
5944 mandeep.dh 17953 
    oprot.writeFieldStop()
17954 
    oprot.writeStructEnd()
17955 
 
17956 
  def validate(self):
17957 
    return
17958 
 
17959 
 
17960 
  def __repr__(self):
17961 
    L = ['%s=%r' % (key, value)
17962 
      for key, value in self.__dict__.iteritems()]
17963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17964 
 
17965 
  def __eq__(self, other):
17966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17967 
 
17968 
  def __ne__(self, other):
17969 
    return not (self == other)
17970 
 
17971 
class getProductNotificationRequestCount_result:
17972 
  """
17973 
  Attributes:
17974 
   - success
17975 
  """
17976 
 
17977 
  thrift_spec = (
17978 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
17979 
  )
17980 
 
17981 
  def __init__(self, success=None,):
17982 
    self.success = success
17983 
 
17984 
  def read(self, iprot):
17985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17987 
      return
17988 
    iprot.readStructBegin()
17989 
    while True:
17990 
      (fname, ftype, fid) = iprot.readFieldBegin()
17991 
      if ftype == TType.STOP:
17992 
        break
17993 
      if fid == 0:
17994 
        if ftype == TType.LIST:
17995 
          self.success = []
9155 kshitij.so 17996 
          (_etype356, _size353) = iprot.readListBegin()
17997 
          for _i357 in xrange(_size353):
17998 
            _elem358 = ProductNotificationRequestCount()
17999 
            _elem358.read(iprot)
18000 
            self.success.append(_elem358)
5944 mandeep.dh 18001 
          iprot.readListEnd()
18002 
        else:
18003 
          iprot.skip(ftype)
18004 
      else:
18005 
        iprot.skip(ftype)
18006 
      iprot.readFieldEnd()
18007 
    iprot.readStructEnd()
18008 
 
18009 
  def write(self, oprot):
18010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18012 
      return
18013 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
18014 
    if self.success is not None:
18015 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18016 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18017 
      for iter359 in self.success:
18018 
        iter359.write(oprot)
5944 mandeep.dh 18019 
      oprot.writeListEnd()
18020 
      oprot.writeFieldEnd()
18021 
    oprot.writeFieldStop()
18022 
    oprot.writeStructEnd()
18023 
 
18024 
  def validate(self):
18025 
    return
18026 
 
18027 
 
18028 
  def __repr__(self):
18029 
    L = ['%s=%r' % (key, value)
18030 
      for key, value in self.__dict__.iteritems()]
18031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18032 
 
18033 
  def __eq__(self, other):
18034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18035 
 
18036 
  def __ne__(self, other):
18037 
    return not (self == other)
18038 
 
18039 
class addAuthorizationLog_args:
18040 
  """
18041 
  Attributes:
18042 
   - itemId
18043 
   - username
18044 
   - reason
18045 
  """
18046 
 
18047 
  thrift_spec = (
18048 
    None, # 0
18049 
    (1, TType.I64, 'itemId', None, None, ), # 1
18050 
    (2, TType.STRING, 'username', None, None, ), # 2
18051 
    (3, TType.STRING, 'reason', None, None, ), # 3
18052 
  )
18053 
 
18054 
  def __init__(self, itemId=None, username=None, reason=None,):
18055 
    self.itemId = itemId
18056 
    self.username = username
18057 
    self.reason = reason
18058 
 
18059 
  def read(self, iprot):
18060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18062 
      return
18063 
    iprot.readStructBegin()
18064 
    while True:
18065 
      (fname, ftype, fid) = iprot.readFieldBegin()
18066 
      if ftype == TType.STOP:
18067 
        break
18068 
      if fid == 1:
18069 
        if ftype == TType.I64:
18070 
          self.itemId = iprot.readI64();
18071 
        else:
18072 
          iprot.skip(ftype)
18073 
      elif fid == 2:
18074 
        if ftype == TType.STRING:
18075 
          self.username = iprot.readString();
18076 
        else:
18077 
          iprot.skip(ftype)
18078 
      elif fid == 3:
18079 
        if ftype == TType.STRING:
18080 
          self.reason = iprot.readString();
18081 
        else:
18082 
          iprot.skip(ftype)
18083 
      else:
18084 
        iprot.skip(ftype)
18085 
      iprot.readFieldEnd()
18086 
    iprot.readStructEnd()
18087 
 
18088 
  def write(self, oprot):
18089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18091 
      return
18092 
    oprot.writeStructBegin('addAuthorizationLog_args')
18093 
    if self.itemId is not None:
18094 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18095 
      oprot.writeI64(self.itemId)
18096 
      oprot.writeFieldEnd()
18097 
    if self.username is not None:
18098 
      oprot.writeFieldBegin('username', TType.STRING, 2)
18099 
      oprot.writeString(self.username)
18100 
      oprot.writeFieldEnd()
18101 
    if self.reason is not None:
18102 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18103 
      oprot.writeString(self.reason)
18104 
      oprot.writeFieldEnd()
18105 
    oprot.writeFieldStop()
18106 
    oprot.writeStructEnd()
18107 
 
18108 
  def validate(self):
18109 
    return
18110 
 
18111 
 
18112 
  def __repr__(self):
18113 
    L = ['%s=%r' % (key, value)
18114 
      for key, value in self.__dict__.iteritems()]
18115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18116 
 
18117 
  def __eq__(self, other):
18118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18119 
 
18120 
  def __ne__(self, other):
18121 
    return not (self == other)
18122 
 
18123 
class addAuthorizationLog_result:
18124 
  """
18125 
  Attributes:
18126 
   - success
18127 
   - cex
18128 
  """
18129 
 
18130 
  thrift_spec = (
18131 
    (0, TType.BOOL, 'success', None, None, ), # 0
18132 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18133 
  )
18134 
 
18135 
  def __init__(self, success=None, cex=None,):
18136 
    self.success = success
18137 
    self.cex = cex
18138 
 
18139 
  def read(self, iprot):
18140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18142 
      return
18143 
    iprot.readStructBegin()
18144 
    while True:
18145 
      (fname, ftype, fid) = iprot.readFieldBegin()
18146 
      if ftype == TType.STOP:
18147 
        break
18148 
      if fid == 0:
18149 
        if ftype == TType.BOOL:
18150 
          self.success = iprot.readBool();
18151 
        else:
18152 
          iprot.skip(ftype)
18153 
      elif fid == 1:
18154 
        if ftype == TType.STRUCT:
18155 
          self.cex = CatalogServiceException()
18156 
          self.cex.read(iprot)
18157 
        else:
18158 
          iprot.skip(ftype)
18159 
      else:
18160 
        iprot.skip(ftype)
18161 
      iprot.readFieldEnd()
18162 
    iprot.readStructEnd()
18163 
 
18164 
  def write(self, oprot):
18165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18167 
      return
18168 
    oprot.writeStructBegin('addAuthorizationLog_result')
18169 
    if self.success is not None:
18170 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18171 
      oprot.writeBool(self.success)
18172 
      oprot.writeFieldEnd()
18173 
    if self.cex is not None:
18174 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18175 
      self.cex.write(oprot)
18176 
      oprot.writeFieldEnd()
18177 
    oprot.writeFieldStop()
18178 
    oprot.writeStructEnd()
18179 
 
18180 
  def validate(self):
18181 
    return
18182 
 
18183 
 
18184 
  def __repr__(self):
18185 
    L = ['%s=%r' % (key, value)
18186 
      for key, value in self.__dict__.iteritems()]
18187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18188 
 
18189 
  def __eq__(self, other):
18190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18191 
 
18192 
  def __ne__(self, other):
18193 
    return not (self == other)
18194 
 
18195 
class addupdateVoucherForItem_args:
18196 
  """
18197 
  Attributes:
18198 
   - catalog_item_id
18199 
   - voucherType
18200 
   - voucherAmount
18201 
  """
18202 
 
18203 
  thrift_spec = (
18204 
    None, # 0
18205 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18206 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18207 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
18208 
  )
18209 
 
18210 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
18211 
    self.catalog_item_id = catalog_item_id
18212 
    self.voucherType = voucherType
18213 
    self.voucherAmount = voucherAmount
18214 
 
18215 
  def read(self, iprot):
18216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18218 
      return
18219 
    iprot.readStructBegin()
18220 
    while True:
18221 
      (fname, ftype, fid) = iprot.readFieldBegin()
18222 
      if ftype == TType.STOP:
18223 
        break
18224 
      if fid == 1:
18225 
        if ftype == TType.I64:
18226 
          self.catalog_item_id = iprot.readI64();
18227 
        else:
18228 
          iprot.skip(ftype)
18229 
      elif fid == 2:
18230 
        if ftype == TType.I64:
18231 
          self.voucherType = iprot.readI64();
18232 
        else:
18233 
          iprot.skip(ftype)
18234 
      elif fid == 3:
18235 
        if ftype == TType.I64:
18236 
          self.voucherAmount = iprot.readI64();
18237 
        else:
18238 
          iprot.skip(ftype)
18239 
      else:
18240 
        iprot.skip(ftype)
18241 
      iprot.readFieldEnd()
18242 
    iprot.readStructEnd()
18243 
 
18244 
  def write(self, oprot):
18245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18247 
      return
18248 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
18249 
    if self.catalog_item_id is not None:
18250 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18251 
      oprot.writeI64(self.catalog_item_id)
18252 
      oprot.writeFieldEnd()
18253 
    if self.voucherType is not None:
18254 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18255 
      oprot.writeI64(self.voucherType)
18256 
      oprot.writeFieldEnd()
18257 
    if self.voucherAmount is not None:
18258 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
18259 
      oprot.writeI64(self.voucherAmount)
18260 
      oprot.writeFieldEnd()
18261 
    oprot.writeFieldStop()
18262 
    oprot.writeStructEnd()
18263 
 
18264 
  def validate(self):
18265 
    return
18266 
 
18267 
 
18268 
  def __repr__(self):
18269 
    L = ['%s=%r' % (key, value)
18270 
      for key, value in self.__dict__.iteritems()]
18271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18272 
 
18273 
  def __eq__(self, other):
18274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18275 
 
18276 
  def __ne__(self, other):
18277 
    return not (self == other)
18278 
 
18279 
class addupdateVoucherForItem_result:
18280 
  """
18281 
  Attributes:
18282 
   - success
18283 
   - cex
18284 
  """
18285 
 
18286 
  thrift_spec = (
18287 
    (0, TType.BOOL, 'success', None, None, ), # 0
18288 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18289 
  )
18290 
 
18291 
  def __init__(self, success=None, cex=None,):
18292 
    self.success = success
18293 
    self.cex = cex
18294 
 
18295 
  def read(self, iprot):
18296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18298 
      return
18299 
    iprot.readStructBegin()
18300 
    while True:
18301 
      (fname, ftype, fid) = iprot.readFieldBegin()
18302 
      if ftype == TType.STOP:
18303 
        break
18304 
      if fid == 0:
18305 
        if ftype == TType.BOOL:
18306 
          self.success = iprot.readBool();
18307 
        else:
18308 
          iprot.skip(ftype)
18309 
      elif fid == 1:
18310 
        if ftype == TType.STRUCT:
18311 
          self.cex = CatalogServiceException()
18312 
          self.cex.read(iprot)
18313 
        else:
18314 
          iprot.skip(ftype)
18315 
      else:
18316 
        iprot.skip(ftype)
18317 
      iprot.readFieldEnd()
18318 
    iprot.readStructEnd()
18319 
 
18320 
  def write(self, oprot):
18321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18323 
      return
18324 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
18325 
    if self.success is not None:
18326 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18327 
      oprot.writeBool(self.success)
18328 
      oprot.writeFieldEnd()
18329 
    if self.cex is not None:
18330 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18331 
      self.cex.write(oprot)
18332 
      oprot.writeFieldEnd()
18333 
    oprot.writeFieldStop()
18334 
    oprot.writeStructEnd()
18335 
 
18336 
  def validate(self):
18337 
    return
18338 
 
18339 
 
18340 
  def __repr__(self):
18341 
    L = ['%s=%r' % (key, value)
18342 
      for key, value in self.__dict__.iteritems()]
18343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18344 
 
18345 
  def __eq__(self, other):
18346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18347 
 
18348 
  def __ne__(self, other):
18349 
    return not (self == other)
18350 
 
18351 
class deleteVoucherForItem_args:
18352 
  """
18353 
  Attributes:
18354 
   - catalog_item_id
18355 
   - voucherType
18356 
  """
18357 
 
18358 
  thrift_spec = (
18359 
    None, # 0
18360 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18361 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18362 
  )
18363 
 
18364 
  def __init__(self, catalog_item_id=None, voucherType=None,):
18365 
    self.catalog_item_id = catalog_item_id
18366 
    self.voucherType = voucherType
18367 
 
18368 
  def read(self, iprot):
18369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18371 
      return
18372 
    iprot.readStructBegin()
18373 
    while True:
18374 
      (fname, ftype, fid) = iprot.readFieldBegin()
18375 
      if ftype == TType.STOP:
18376 
        break
18377 
      if fid == 1:
18378 
        if ftype == TType.I64:
18379 
          self.catalog_item_id = iprot.readI64();
18380 
        else:
18381 
          iprot.skip(ftype)
18382 
      elif fid == 2:
18383 
        if ftype == TType.I64:
18384 
          self.voucherType = iprot.readI64();
18385 
        else:
18386 
          iprot.skip(ftype)
18387 
      else:
18388 
        iprot.skip(ftype)
18389 
      iprot.readFieldEnd()
18390 
    iprot.readStructEnd()
18391 
 
18392 
  def write(self, oprot):
18393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18395 
      return
18396 
    oprot.writeStructBegin('deleteVoucherForItem_args')
18397 
    if self.catalog_item_id is not None:
18398 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18399 
      oprot.writeI64(self.catalog_item_id)
18400 
      oprot.writeFieldEnd()
18401 
    if self.voucherType is not None:
18402 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18403 
      oprot.writeI64(self.voucherType)
18404 
      oprot.writeFieldEnd()
18405 
    oprot.writeFieldStop()
18406 
    oprot.writeStructEnd()
18407 
 
18408 
  def validate(self):
18409 
    return
18410 
 
18411 
 
18412 
  def __repr__(self):
18413 
    L = ['%s=%r' % (key, value)
18414 
      for key, value in self.__dict__.iteritems()]
18415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18416 
 
18417 
  def __eq__(self, other):
18418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18419 
 
18420 
  def __ne__(self, other):
18421 
    return not (self == other)
18422 
 
18423 
class deleteVoucherForItem_result:
18424 
  """
18425 
  Attributes:
18426 
   - success
18427 
   - cex
18428 
  """
18429 
 
18430 
  thrift_spec = (
18431 
    (0, TType.BOOL, 'success', None, None, ), # 0
18432 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18433 
  )
18434 
 
18435 
  def __init__(self, success=None, cex=None,):
18436 
    self.success = success
18437 
    self.cex = cex
18438 
 
18439 
  def read(self, iprot):
18440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18442 
      return
18443 
    iprot.readStructBegin()
18444 
    while True:
18445 
      (fname, ftype, fid) = iprot.readFieldBegin()
18446 
      if ftype == TType.STOP:
18447 
        break
18448 
      if fid == 0:
18449 
        if ftype == TType.BOOL:
18450 
          self.success = iprot.readBool();
18451 
        else:
18452 
          iprot.skip(ftype)
18453 
      elif fid == 1:
18454 
        if ftype == TType.STRUCT:
18455 
          self.cex = CatalogServiceException()
18456 
          self.cex.read(iprot)
18457 
        else:
18458 
          iprot.skip(ftype)
18459 
      else:
18460 
        iprot.skip(ftype)
18461 
      iprot.readFieldEnd()
18462 
    iprot.readStructEnd()
18463 
 
18464 
  def write(self, oprot):
18465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18467 
      return
18468 
    oprot.writeStructBegin('deleteVoucherForItem_result')
18469 
    if self.success is not None:
18470 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18471 
      oprot.writeBool(self.success)
18472 
      oprot.writeFieldEnd()
18473 
    if self.cex is not None:
18474 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18475 
      self.cex.write(oprot)
18476 
      oprot.writeFieldEnd()
18477 
    oprot.writeFieldStop()
18478 
    oprot.writeStructEnd()
18479 
 
18480 
  def validate(self):
18481 
    return
18482 
 
18483 
 
18484 
  def __repr__(self):
18485 
    L = ['%s=%r' % (key, value)
18486 
      for key, value in self.__dict__.iteritems()]
18487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18488 
 
18489 
  def __eq__(self, other):
18490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18491 
 
18492 
  def __ne__(self, other):
18493 
    return not (self == other)
18494 
 
18495 
class getVoucherAmount_args:
18496 
  """
18497 
  Attributes:
18498 
   - itemId
18499 
   - voucherType
18500 
  """
18501 
 
18502 
  thrift_spec = (
18503 
    None, # 0
18504 
    (1, TType.I64, 'itemId', None, None, ), # 1
18505 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18506 
  )
18507 
 
18508 
  def __init__(self, itemId=None, voucherType=None,):
18509 
    self.itemId = itemId
18510 
    self.voucherType = voucherType
18511 
 
18512 
  def read(self, iprot):
18513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18515 
      return
18516 
    iprot.readStructBegin()
18517 
    while True:
18518 
      (fname, ftype, fid) = iprot.readFieldBegin()
18519 
      if ftype == TType.STOP:
18520 
        break
18521 
      if fid == 1:
18522 
        if ftype == TType.I64:
18523 
          self.itemId = iprot.readI64();
18524 
        else:
18525 
          iprot.skip(ftype)
18526 
      elif fid == 2:
18527 
        if ftype == TType.I64:
18528 
          self.voucherType = iprot.readI64();
18529 
        else:
18530 
          iprot.skip(ftype)
18531 
      else:
18532 
        iprot.skip(ftype)
18533 
      iprot.readFieldEnd()
18534 
    iprot.readStructEnd()
18535 
 
18536 
  def write(self, oprot):
18537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18539 
      return
18540 
    oprot.writeStructBegin('getVoucherAmount_args')
18541 
    if self.itemId is not None:
18542 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18543 
      oprot.writeI64(self.itemId)
18544 
      oprot.writeFieldEnd()
18545 
    if self.voucherType is not None:
18546 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18547 
      oprot.writeI64(self.voucherType)
18548 
      oprot.writeFieldEnd()
18549 
    oprot.writeFieldStop()
18550 
    oprot.writeStructEnd()
18551 
 
18552 
  def validate(self):
18553 
    return
18554 
 
18555 
 
18556 
  def __repr__(self):
18557 
    L = ['%s=%r' % (key, value)
18558 
      for key, value in self.__dict__.iteritems()]
18559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18560 
 
18561 
  def __eq__(self, other):
18562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18563 
 
18564 
  def __ne__(self, other):
18565 
    return not (self == other)
18566 
 
18567 
class getVoucherAmount_result:
18568 
  """
18569 
  Attributes:
18570 
   - success
18571 
  """
18572 
 
18573 
  thrift_spec = (
18574 
    (0, TType.I64, 'success', None, None, ), # 0
18575 
  )
18576 
 
18577 
  def __init__(self, success=None,):
18578 
    self.success = success
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.I64:
18591 
          self.success = iprot.readI64();
18592 
        else:
18593 
          iprot.skip(ftype)
18594 
      else:
18595 
        iprot.skip(ftype)
18596 
      iprot.readFieldEnd()
18597 
    iprot.readStructEnd()
18598 
 
18599 
  def write(self, oprot):
18600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18602 
      return
18603 
    oprot.writeStructBegin('getVoucherAmount_result')
18604 
    if self.success is not None:
18605 
      oprot.writeFieldBegin('success', TType.I64, 0)
18606 
      oprot.writeI64(self.success)
18607 
      oprot.writeFieldEnd()
18608 
    oprot.writeFieldStop()
18609 
    oprot.writeStructEnd()
18610 
 
18611 
  def validate(self):
18612 
    return
18613 
 
18614 
 
18615 
  def __repr__(self):
18616 
    L = ['%s=%r' % (key, value)
18617 
      for key, value in self.__dict__.iteritems()]
18618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18619 
 
18620 
  def __eq__(self, other):
18621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18622 
 
18623 
  def __ne__(self, other):
18624 
    return not (self == other)
18625 
 
18626 
class getAllItemVouchers_args:
18627 
  """
18628 
  Attributes:
18629 
   - itemId
18630 
  """
18631 
 
18632 
  thrift_spec = (
18633 
    None, # 0
18634 
    (1, TType.I64, 'itemId', None, None, ), # 1
18635 
  )
18636 
 
18637 
  def __init__(self, itemId=None,):
18638 
    self.itemId = itemId
18639 
 
18640 
  def read(self, iprot):
18641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18643 
      return
18644 
    iprot.readStructBegin()
18645 
    while True:
18646 
      (fname, ftype, fid) = iprot.readFieldBegin()
18647 
      if ftype == TType.STOP:
18648 
        break
18649 
      if fid == 1:
18650 
        if ftype == TType.I64:
18651 
          self.itemId = iprot.readI64();
18652 
        else:
18653 
          iprot.skip(ftype)
18654 
      else:
18655 
        iprot.skip(ftype)
18656 
      iprot.readFieldEnd()
18657 
    iprot.readStructEnd()
18658 
 
18659 
  def write(self, oprot):
18660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18662 
      return
18663 
    oprot.writeStructBegin('getAllItemVouchers_args')
18664 
    if self.itemId is not None:
18665 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18666 
      oprot.writeI64(self.itemId)
18667 
      oprot.writeFieldEnd()
18668 
    oprot.writeFieldStop()
18669 
    oprot.writeStructEnd()
18670 
 
18671 
  def validate(self):
18672 
    return
18673 
 
18674 
 
18675 
  def __repr__(self):
18676 
    L = ['%s=%r' % (key, value)
18677 
      for key, value in self.__dict__.iteritems()]
18678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18679 
 
18680 
  def __eq__(self, other):
18681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18682 
 
18683 
  def __ne__(self, other):
18684 
    return not (self == other)
18685 
 
18686 
class getAllItemVouchers_result:
18687 
  """
18688 
  Attributes:
18689 
   - success
18690 
  """
18691 
 
18692 
  thrift_spec = (
18693 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
18694 
  )
18695 
 
18696 
  def __init__(self, success=None,):
18697 
    self.success = success
18698 
 
18699 
  def read(self, iprot):
18700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18702 
      return
18703 
    iprot.readStructBegin()
18704 
    while True:
18705 
      (fname, ftype, fid) = iprot.readFieldBegin()
18706 
      if ftype == TType.STOP:
18707 
        break
18708 
      if fid == 0:
18709 
        if ftype == TType.LIST:
18710 
          self.success = []
9155 kshitij.so 18711 
          (_etype363, _size360) = iprot.readListBegin()
18712 
          for _i364 in xrange(_size360):
18713 
            _elem365 = VoucherItemMapping()
18714 
            _elem365.read(iprot)
18715 
            self.success.append(_elem365)
5944 mandeep.dh 18716 
          iprot.readListEnd()
18717 
        else:
18718 
          iprot.skip(ftype)
18719 
      else:
18720 
        iprot.skip(ftype)
18721 
      iprot.readFieldEnd()
18722 
    iprot.readStructEnd()
18723 
 
18724 
  def write(self, oprot):
18725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18727 
      return
18728 
    oprot.writeStructBegin('getAllItemVouchers_result')
18729 
    if self.success is not None:
18730 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18731 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18732 
      for iter366 in self.success:
18733 
        iter366.write(oprot)
5944 mandeep.dh 18734 
      oprot.writeListEnd()
18735 
      oprot.writeFieldEnd()
18736 
    oprot.writeFieldStop()
18737 
    oprot.writeStructEnd()
18738 
 
18739 
  def validate(self):
18740 
    return
18741 
 
18742 
 
18743 
  def __repr__(self):
18744 
    L = ['%s=%r' % (key, value)
18745 
      for key, value in self.__dict__.iteritems()]
18746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18747 
 
18748 
  def __eq__(self, other):
18749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18750 
 
18751 
  def __ne__(self, other):
18752 
    return not (self == other)
18753 
 
18754 
class isValidCatalogItemId_args:
18755 
  """
18756 
  Attributes:
18757 
   - catalog_item_id
18758 
  """
18759 
 
18760 
  thrift_spec = (
18761 
    None, # 0
18762 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18763 
  )
18764 
 
18765 
  def __init__(self, catalog_item_id=None,):
18766 
    self.catalog_item_id = catalog_item_id
18767 
 
18768 
  def read(self, iprot):
18769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18771 
      return
18772 
    iprot.readStructBegin()
18773 
    while True:
18774 
      (fname, ftype, fid) = iprot.readFieldBegin()
18775 
      if ftype == TType.STOP:
18776 
        break
18777 
      if fid == 1:
18778 
        if ftype == TType.I64:
18779 
          self.catalog_item_id = iprot.readI64();
18780 
        else:
18781 
          iprot.skip(ftype)
18782 
      else:
18783 
        iprot.skip(ftype)
18784 
      iprot.readFieldEnd()
18785 
    iprot.readStructEnd()
18786 
 
18787 
  def write(self, oprot):
18788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18790 
      return
18791 
    oprot.writeStructBegin('isValidCatalogItemId_args')
18792 
    if self.catalog_item_id is not None:
18793 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18794 
      oprot.writeI64(self.catalog_item_id)
18795 
      oprot.writeFieldEnd()
18796 
    oprot.writeFieldStop()
18797 
    oprot.writeStructEnd()
18798 
 
18799 
  def validate(self):
18800 
    return
18801 
 
18802 
 
18803 
  def __repr__(self):
18804 
    L = ['%s=%r' % (key, value)
18805 
      for key, value in self.__dict__.iteritems()]
18806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18807 
 
18808 
  def __eq__(self, other):
18809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18810 
 
18811 
  def __ne__(self, other):
18812 
    return not (self == other)
18813 
 
18814 
class isValidCatalogItemId_result:
18815 
  """
18816 
  Attributes:
18817 
   - success
18818 
  """
18819 
 
18820 
  thrift_spec = (
18821 
    (0, TType.BOOL, 'success', None, None, ), # 0
18822 
  )
18823 
 
18824 
  def __init__(self, success=None,):
18825 
    self.success = success
18826 
 
18827 
  def read(self, iprot):
18828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18830 
      return
18831 
    iprot.readStructBegin()
18832 
    while True:
18833 
      (fname, ftype, fid) = iprot.readFieldBegin()
18834 
      if ftype == TType.STOP:
18835 
        break
18836 
      if fid == 0:
18837 
        if ftype == TType.BOOL:
18838 
          self.success = iprot.readBool();
18839 
        else:
18840 
          iprot.skip(ftype)
18841 
      else:
18842 
        iprot.skip(ftype)
18843 
      iprot.readFieldEnd()
18844 
    iprot.readStructEnd()
18845 
 
18846 
  def write(self, oprot):
18847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18849 
      return
18850 
    oprot.writeStructBegin('isValidCatalogItemId_result')
18851 
    if self.success is not None:
18852 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18853 
      oprot.writeBool(self.success)
18854 
      oprot.writeFieldEnd()
18855 
    oprot.writeFieldStop()
18856 
    oprot.writeStructEnd()
18857 
 
18858 
  def validate(self):
18859 
    return
18860 
 
18861 
 
18862 
  def __repr__(self):
18863 
    L = ['%s=%r' % (key, value)
18864 
      for key, value in self.__dict__.iteritems()]
18865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18866 
 
18867 
  def __eq__(self, other):
18868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18869 
 
18870 
  def __ne__(self, other):
18871 
    return not (self == other)
6039 amit.gupta 18872 
 
18873 
class getVatPercentageForItem_args:
18874 
  """
18875 
  Attributes:
18876 
   - itemId
7330 amit.gupta 18877 
   - stateId
6039 amit.gupta 18878 
   - price
18879 
  """
18880 
 
18881 
  thrift_spec = (
18882 
    None, # 0
18883 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 18884 
    (2, TType.I64, 'stateId', None, None, ), # 2
18885 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 18886 
  )
18887 
 
7330 amit.gupta 18888 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 18889 
    self.itemId = itemId
7330 amit.gupta 18890 
    self.stateId = stateId
6039 amit.gupta 18891 
    self.price = price
18892 
 
18893 
  def read(self, iprot):
18894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18896 
      return
18897 
    iprot.readStructBegin()
18898 
    while True:
18899 
      (fname, ftype, fid) = iprot.readFieldBegin()
18900 
      if ftype == TType.STOP:
18901 
        break
18902 
      if fid == 1:
18903 
        if ftype == TType.I64:
18904 
          self.itemId = iprot.readI64();
18905 
        else:
18906 
          iprot.skip(ftype)
18907 
      elif fid == 2:
7330 amit.gupta 18908 
        if ftype == TType.I64:
18909 
          self.stateId = iprot.readI64();
18910 
        else:
18911 
          iprot.skip(ftype)
18912 
      elif fid == 3:
6039 amit.gupta 18913 
        if ftype == TType.DOUBLE:
18914 
          self.price = iprot.readDouble();
18915 
        else:
18916 
          iprot.skip(ftype)
18917 
      else:
18918 
        iprot.skip(ftype)
18919 
      iprot.readFieldEnd()
18920 
    iprot.readStructEnd()
18921 
 
18922 
  def write(self, oprot):
18923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18925 
      return
18926 
    oprot.writeStructBegin('getVatPercentageForItem_args')
18927 
    if self.itemId is not None:
18928 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18929 
      oprot.writeI64(self.itemId)
18930 
      oprot.writeFieldEnd()
7330 amit.gupta 18931 
    if self.stateId is not None:
18932 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
18933 
      oprot.writeI64(self.stateId)
18934 
      oprot.writeFieldEnd()
6039 amit.gupta 18935 
    if self.price is not None:
7330 amit.gupta 18936 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 18937 
      oprot.writeDouble(self.price)
18938 
      oprot.writeFieldEnd()
18939 
    oprot.writeFieldStop()
18940 
    oprot.writeStructEnd()
18941 
 
18942 
  def validate(self):
18943 
    return
18944 
 
18945 
 
18946 
  def __repr__(self):
18947 
    L = ['%s=%r' % (key, value)
18948 
      for key, value in self.__dict__.iteritems()]
18949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18950 
 
18951 
  def __eq__(self, other):
18952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18953 
 
18954 
  def __ne__(self, other):
18955 
    return not (self == other)
18956 
 
18957 
class getVatPercentageForItem_result:
18958 
  """
18959 
  Attributes:
18960 
   - success
7340 amit.gupta 18961 
   - cex
6039 amit.gupta 18962 
  """
18963 
 
18964 
  thrift_spec = (
18965 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 18966 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 18967 
  )
18968 
 
7340 amit.gupta 18969 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 18970 
    self.success = success
7340 amit.gupta 18971 
    self.cex = cex
6039 amit.gupta 18972 
 
18973 
  def read(self, iprot):
18974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18976 
      return
18977 
    iprot.readStructBegin()
18978 
    while True:
18979 
      (fname, ftype, fid) = iprot.readFieldBegin()
18980 
      if ftype == TType.STOP:
18981 
        break
18982 
      if fid == 0:
18983 
        if ftype == TType.DOUBLE:
18984 
          self.success = iprot.readDouble();
18985 
        else:
18986 
          iprot.skip(ftype)
7340 amit.gupta 18987 
      elif fid == 1:
18988 
        if ftype == TType.STRUCT:
18989 
          self.cex = CatalogServiceException()
18990 
          self.cex.read(iprot)
18991 
        else:
18992 
          iprot.skip(ftype)
6039 amit.gupta 18993 
      else:
18994 
        iprot.skip(ftype)
18995 
      iprot.readFieldEnd()
18996 
    iprot.readStructEnd()
18997 
 
18998 
  def write(self, oprot):
18999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19001 
      return
19002 
    oprot.writeStructBegin('getVatPercentageForItem_result')
19003 
    if self.success is not None:
19004 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
19005 
      oprot.writeDouble(self.success)
19006 
      oprot.writeFieldEnd()
7340 amit.gupta 19007 
    if self.cex is not None:
19008 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19009 
      self.cex.write(oprot)
19010 
      oprot.writeFieldEnd()
6039 amit.gupta 19011 
    oprot.writeFieldStop()
19012 
    oprot.writeStructEnd()
19013 
 
19014 
  def validate(self):
19015 
    return
19016 
 
19017 
 
19018 
  def __repr__(self):
19019 
    L = ['%s=%r' % (key, value)
19020 
      for key, value in self.__dict__.iteritems()]
19021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19022 
 
19023 
  def __eq__(self, other):
19024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19025 
 
19026 
  def __ne__(self, other):
19027 
    return not (self == other)
19028 
 
19029 
class getVatAmountForItem_args:
19030 
  """
19031 
  Attributes:
19032 
   - itemId
19033 
   - price
19034 
  """
19035 
 
19036 
  thrift_spec = (
19037 
    None, # 0
19038 
    (1, TType.I64, 'itemId', None, None, ), # 1
19039 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
19040 
  )
19041 
 
19042 
  def __init__(self, itemId=None, price=None,):
19043 
    self.itemId = itemId
19044 
    self.price = price
19045 
 
19046 
  def read(self, iprot):
19047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19049 
      return
19050 
    iprot.readStructBegin()
19051 
    while True:
19052 
      (fname, ftype, fid) = iprot.readFieldBegin()
19053 
      if ftype == TType.STOP:
19054 
        break
19055 
      if fid == 1:
19056 
        if ftype == TType.I64:
19057 
          self.itemId = iprot.readI64();
19058 
        else:
19059 
          iprot.skip(ftype)
19060 
      elif fid == 2:
19061 
        if ftype == TType.DOUBLE:
19062 
          self.price = iprot.readDouble();
19063 
        else:
19064 
          iprot.skip(ftype)
19065 
      else:
19066 
        iprot.skip(ftype)
19067 
      iprot.readFieldEnd()
19068 
    iprot.readStructEnd()
19069 
 
19070 
  def write(self, oprot):
19071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19073 
      return
19074 
    oprot.writeStructBegin('getVatAmountForItem_args')
19075 
    if self.itemId is not None:
19076 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19077 
      oprot.writeI64(self.itemId)
19078 
      oprot.writeFieldEnd()
19079 
    if self.price is not None:
19080 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
19081 
      oprot.writeDouble(self.price)
19082 
      oprot.writeFieldEnd()
19083 
    oprot.writeFieldStop()
19084 
    oprot.writeStructEnd()
19085 
 
19086 
  def validate(self):
19087 
    return
19088 
 
19089 
 
19090 
  def __repr__(self):
19091 
    L = ['%s=%r' % (key, value)
19092 
      for key, value in self.__dict__.iteritems()]
19093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19094 
 
19095 
  def __eq__(self, other):
19096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19097 
 
19098 
  def __ne__(self, other):
19099 
    return not (self == other)
19100 
 
19101 
class getVatAmountForItem_result:
19102 
  """
19103 
  Attributes:
19104 
   - success
19105 
  """
19106 
 
19107 
  thrift_spec = (
19108 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
19109 
  )
19110 
 
19111 
  def __init__(self, success=None,):
19112 
    self.success = success
19113 
 
19114 
  def read(self, iprot):
19115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19117 
      return
19118 
    iprot.readStructBegin()
19119 
    while True:
19120 
      (fname, ftype, fid) = iprot.readFieldBegin()
19121 
      if ftype == TType.STOP:
19122 
        break
19123 
      if fid == 0:
19124 
        if ftype == TType.DOUBLE:
19125 
          self.success = iprot.readDouble();
19126 
        else:
19127 
          iprot.skip(ftype)
19128 
      else:
19129 
        iprot.skip(ftype)
19130 
      iprot.readFieldEnd()
19131 
    iprot.readStructEnd()
19132 
 
19133 
  def write(self, oprot):
19134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19136 
      return
19137 
    oprot.writeStructBegin('getVatAmountForItem_result')
19138 
    if self.success is not None:
19139 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
19140 
      oprot.writeDouble(self.success)
19141 
      oprot.writeFieldEnd()
19142 
    oprot.writeFieldStop()
19143 
    oprot.writeStructEnd()
19144 
 
19145 
  def validate(self):
19146 
    return
19147 
 
19148 
 
19149 
  def __repr__(self):
19150 
    L = ['%s=%r' % (key, value)
19151 
      for key, value in self.__dict__.iteritems()]
19152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19153 
 
19154 
  def __eq__(self, other):
19155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19156 
 
19157 
  def __ne__(self, other):
19158 
    return not (self == other)
6531 vikram.rag 19159 
 
19160 
class getAllIgnoredInventoryUpdateItemsList_args:
19161 
  """
19162 
  Attributes:
19163 
   - offset
19164 
   - limit
19165 
  """
19166 
 
19167 
  thrift_spec = (
19168 
    None, # 0
19169 
    (1, TType.I32, 'offset', None, None, ), # 1
19170 
    (2, TType.I32, 'limit', None, None, ), # 2
19171 
  )
19172 
 
19173 
  def __init__(self, offset=None, limit=None,):
19174 
    self.offset = offset
19175 
    self.limit = limit
19176 
 
19177 
  def read(self, iprot):
19178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19180 
      return
19181 
    iprot.readStructBegin()
19182 
    while True:
19183 
      (fname, ftype, fid) = iprot.readFieldBegin()
19184 
      if ftype == TType.STOP:
19185 
        break
19186 
      if fid == 1:
19187 
        if ftype == TType.I32:
19188 
          self.offset = iprot.readI32();
19189 
        else:
19190 
          iprot.skip(ftype)
19191 
      elif fid == 2:
19192 
        if ftype == TType.I32:
19193 
          self.limit = iprot.readI32();
19194 
        else:
19195 
          iprot.skip(ftype)
19196 
      else:
19197 
        iprot.skip(ftype)
19198 
      iprot.readFieldEnd()
19199 
    iprot.readStructEnd()
19200 
 
19201 
  def write(self, oprot):
19202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19204 
      return
19205 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
19206 
    if self.offset is not None:
19207 
      oprot.writeFieldBegin('offset', TType.I32, 1)
19208 
      oprot.writeI32(self.offset)
19209 
      oprot.writeFieldEnd()
19210 
    if self.limit is not None:
19211 
      oprot.writeFieldBegin('limit', TType.I32, 2)
19212 
      oprot.writeI32(self.limit)
19213 
      oprot.writeFieldEnd()
19214 
    oprot.writeFieldStop()
19215 
    oprot.writeStructEnd()
19216 
 
19217 
  def validate(self):
19218 
    return
19219 
 
19220 
 
19221 
  def __repr__(self):
19222 
    L = ['%s=%r' % (key, value)
19223 
      for key, value in self.__dict__.iteritems()]
19224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19225 
 
19226 
  def __eq__(self, other):
19227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19228 
 
19229 
  def __ne__(self, other):
19230 
    return not (self == other)
19231 
 
19232 
class getAllIgnoredInventoryUpdateItemsList_result:
19233 
  """
19234 
  Attributes:
19235 
   - success
19236 
  """
19237 
 
19238 
  thrift_spec = (
19239 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19240 
  )
19241 
 
19242 
  def __init__(self, success=None,):
19243 
    self.success = success
19244 
 
19245 
  def read(self, iprot):
19246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19248 
      return
19249 
    iprot.readStructBegin()
19250 
    while True:
19251 
      (fname, ftype, fid) = iprot.readFieldBegin()
19252 
      if ftype == TType.STOP:
19253 
        break
19254 
      if fid == 0:
19255 
        if ftype == TType.LIST:
19256 
          self.success = []
9155 kshitij.so 19257 
          (_etype370, _size367) = iprot.readListBegin()
19258 
          for _i371 in xrange(_size367):
19259 
            _elem372 = Item()
19260 
            _elem372.read(iprot)
19261 
            self.success.append(_elem372)
6531 vikram.rag 19262 
          iprot.readListEnd()
19263 
        else:
19264 
          iprot.skip(ftype)
19265 
      else:
19266 
        iprot.skip(ftype)
19267 
      iprot.readFieldEnd()
19268 
    iprot.readStructEnd()
19269 
 
19270 
  def write(self, oprot):
19271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19273 
      return
19274 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
19275 
    if self.success is not None:
19276 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19277 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19278 
      for iter373 in self.success:
19279 
        iter373.write(oprot)
6531 vikram.rag 19280 
      oprot.writeListEnd()
19281 
      oprot.writeFieldEnd()
19282 
    oprot.writeFieldStop()
19283 
    oprot.writeStructEnd()
19284 
 
19285 
  def validate(self):
19286 
    return
19287 
 
19288 
 
19289 
  def __repr__(self):
19290 
    L = ['%s=%r' % (key, value)
19291 
      for key, value in self.__dict__.iteritems()]
19292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19293 
 
19294 
  def __eq__(self, other):
19295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19296 
 
19297 
  def __ne__(self, other):
19298 
    return not (self == other)
6805 anupam.sin 19299 
 
6821 amar.kumar 19300 
class getAllAliveItems_args:
19301 
 
19302 
  thrift_spec = (
19303 
  )
19304 
 
19305 
  def read(self, iprot):
19306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19308 
      return
19309 
    iprot.readStructBegin()
19310 
    while True:
19311 
      (fname, ftype, fid) = iprot.readFieldBegin()
19312 
      if ftype == TType.STOP:
19313 
        break
19314 
      else:
19315 
        iprot.skip(ftype)
19316 
      iprot.readFieldEnd()
19317 
    iprot.readStructEnd()
19318 
 
19319 
  def write(self, oprot):
19320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19322 
      return
19323 
    oprot.writeStructBegin('getAllAliveItems_args')
19324 
    oprot.writeFieldStop()
19325 
    oprot.writeStructEnd()
19326 
 
19327 
  def validate(self):
19328 
    return
19329 
 
19330 
 
19331 
  def __repr__(self):
19332 
    L = ['%s=%r' % (key, value)
19333 
      for key, value in self.__dict__.iteritems()]
19334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19335 
 
19336 
  def __eq__(self, other):
19337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19338 
 
19339 
  def __ne__(self, other):
19340 
    return not (self == other)
19341 
 
19342 
class getAllAliveItems_result:
19343 
  """
19344 
  Attributes:
19345 
   - success
19346 
  """
19347 
 
19348 
  thrift_spec = (
19349 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19350 
  )
19351 
 
19352 
  def __init__(self, success=None,):
19353 
    self.success = success
19354 
 
19355 
  def read(self, iprot):
19356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19358 
      return
19359 
    iprot.readStructBegin()
19360 
    while True:
19361 
      (fname, ftype, fid) = iprot.readFieldBegin()
19362 
      if ftype == TType.STOP:
19363 
        break
19364 
      if fid == 0:
19365 
        if ftype == TType.LIST:
19366 
          self.success = []
9155 kshitij.so 19367 
          (_etype377, _size374) = iprot.readListBegin()
19368 
          for _i378 in xrange(_size374):
19369 
            _elem379 = Item()
19370 
            _elem379.read(iprot)
19371 
            self.success.append(_elem379)
6821 amar.kumar 19372 
          iprot.readListEnd()
19373 
        else:
19374 
          iprot.skip(ftype)
19375 
      else:
19376 
        iprot.skip(ftype)
19377 
      iprot.readFieldEnd()
19378 
    iprot.readStructEnd()
19379 
 
19380 
  def write(self, oprot):
19381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19383 
      return
19384 
    oprot.writeStructBegin('getAllAliveItems_result')
19385 
    if self.success is not None:
19386 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19387 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19388 
      for iter380 in self.success:
19389 
        iter380.write(oprot)
6821 amar.kumar 19390 
      oprot.writeListEnd()
19391 
      oprot.writeFieldEnd()
19392 
    oprot.writeFieldStop()
19393 
    oprot.writeStructEnd()
19394 
 
19395 
  def validate(self):
19396 
    return
19397 
 
19398 
 
19399 
  def __repr__(self):
19400 
    L = ['%s=%r' % (key, value)
19401 
      for key, value in self.__dict__.iteritems()]
19402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19403 
 
19404 
  def __eq__(self, other):
19405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19406 
 
19407 
  def __ne__(self, other):
19408 
    return not (self == other)
19409 
 
6805 anupam.sin 19410 
class getInsuranceAmount_args:
19411 
  """
19412 
  Attributes:
19413 
   - itemId
6921 anupam.sin 19414 
   - price
6805 anupam.sin 19415 
   - insurerId
19416 
   - quantity
19417 
  """
19418 
 
19419 
  thrift_spec = (
19420 
    None, # 0
19421 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 19422 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
19423 
    (3, TType.I64, 'insurerId', None, None, ), # 3
19424 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 19425 
  )
19426 
 
6921 anupam.sin 19427 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 19428 
    self.itemId = itemId
6921 anupam.sin 19429 
    self.price = price
6805 anupam.sin 19430 
    self.insurerId = insurerId
19431 
    self.quantity = quantity
19432 
 
19433 
  def read(self, iprot):
19434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19436 
      return
19437 
    iprot.readStructBegin()
19438 
    while True:
19439 
      (fname, ftype, fid) = iprot.readFieldBegin()
19440 
      if ftype == TType.STOP:
19441 
        break
19442 
      if fid == 1:
19443 
        if ftype == TType.I64:
19444 
          self.itemId = iprot.readI64();
19445 
        else:
19446 
          iprot.skip(ftype)
19447 
      elif fid == 2:
6921 anupam.sin 19448 
        if ftype == TType.DOUBLE:
19449 
          self.price = iprot.readDouble();
19450 
        else:
19451 
          iprot.skip(ftype)
19452 
      elif fid == 3:
6805 anupam.sin 19453 
        if ftype == TType.I64:
19454 
          self.insurerId = iprot.readI64();
19455 
        else:
19456 
          iprot.skip(ftype)
6921 anupam.sin 19457 
      elif fid == 4:
6805 anupam.sin 19458 
        if ftype == TType.I64:
19459 
          self.quantity = iprot.readI64();
19460 
        else:
19461 
          iprot.skip(ftype)
19462 
      else:
19463 
        iprot.skip(ftype)
19464 
      iprot.readFieldEnd()
19465 
    iprot.readStructEnd()
19466 
 
19467 
  def write(self, oprot):
19468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19470 
      return
19471 
    oprot.writeStructBegin('getInsuranceAmount_args')
19472 
    if self.itemId is not None:
19473 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19474 
      oprot.writeI64(self.itemId)
19475 
      oprot.writeFieldEnd()
6921 anupam.sin 19476 
    if self.price is not None:
19477 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
19478 
      oprot.writeDouble(self.price)
19479 
      oprot.writeFieldEnd()
6805 anupam.sin 19480 
    if self.insurerId is not None:
6921 anupam.sin 19481 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 19482 
      oprot.writeI64(self.insurerId)
19483 
      oprot.writeFieldEnd()
19484 
    if self.quantity is not None:
6921 anupam.sin 19485 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 19486 
      oprot.writeI64(self.quantity)
19487 
      oprot.writeFieldEnd()
19488 
    oprot.writeFieldStop()
19489 
    oprot.writeStructEnd()
19490 
 
19491 
  def validate(self):
19492 
    return
19493 
 
19494 
 
19495 
  def __repr__(self):
19496 
    L = ['%s=%r' % (key, value)
19497 
      for key, value in self.__dict__.iteritems()]
19498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19499 
 
19500 
  def __eq__(self, other):
19501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19502 
 
19503 
  def __ne__(self, other):
19504 
    return not (self == other)
19505 
 
19506 
class getInsuranceAmount_result:
19507 
  """
19508 
  Attributes:
19509 
   - success
19510 
  """
19511 
 
19512 
  thrift_spec = (
19513 
    (0, TType.I64, 'success', None, None, ), # 0
19514 
  )
19515 
 
19516 
  def __init__(self, success=None,):
19517 
    self.success = success
19518 
 
19519 
  def read(self, iprot):
19520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19522 
      return
19523 
    iprot.readStructBegin()
19524 
    while True:
19525 
      (fname, ftype, fid) = iprot.readFieldBegin()
19526 
      if ftype == TType.STOP:
19527 
        break
19528 
      if fid == 0:
19529 
        if ftype == TType.I64:
19530 
          self.success = iprot.readI64();
19531 
        else:
19532 
          iprot.skip(ftype)
19533 
      else:
19534 
        iprot.skip(ftype)
19535 
      iprot.readFieldEnd()
19536 
    iprot.readStructEnd()
19537 
 
19538 
  def write(self, oprot):
19539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19541 
      return
19542 
    oprot.writeStructBegin('getInsuranceAmount_result')
19543 
    if self.success is not None:
19544 
      oprot.writeFieldBegin('success', TType.I64, 0)
19545 
      oprot.writeI64(self.success)
19546 
      oprot.writeFieldEnd()
19547 
    oprot.writeFieldStop()
19548 
    oprot.writeStructEnd()
19549 
 
19550 
  def validate(self):
19551 
    return
19552 
 
19553 
 
19554 
  def __repr__(self):
19555 
    L = ['%s=%r' % (key, value)
19556 
      for key, value in self.__dict__.iteritems()]
19557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19558 
 
19559 
  def __eq__(self, other):
19560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19561 
 
19562 
  def __ne__(self, other):
19563 
    return not (self == other)
19564 
 
19565 
class getInsurer_args:
19566 
  """
19567 
  Attributes:
19568 
   - insurerId
19569 
  """
19570 
 
19571 
  thrift_spec = (
19572 
    None, # 0
19573 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19574 
  )
19575 
 
19576 
  def __init__(self, insurerId=None,):
19577 
    self.insurerId = insurerId
19578 
 
19579 
  def read(self, iprot):
19580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19582 
      return
19583 
    iprot.readStructBegin()
19584 
    while True:
19585 
      (fname, ftype, fid) = iprot.readFieldBegin()
19586 
      if ftype == TType.STOP:
19587 
        break
19588 
      if fid == 1:
19589 
        if ftype == TType.I64:
19590 
          self.insurerId = iprot.readI64();
19591 
        else:
19592 
          iprot.skip(ftype)
19593 
      else:
19594 
        iprot.skip(ftype)
19595 
      iprot.readFieldEnd()
19596 
    iprot.readStructEnd()
19597 
 
19598 
  def write(self, oprot):
19599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19601 
      return
19602 
    oprot.writeStructBegin('getInsurer_args')
19603 
    if self.insurerId is not None:
19604 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19605 
      oprot.writeI64(self.insurerId)
19606 
      oprot.writeFieldEnd()
19607 
    oprot.writeFieldStop()
19608 
    oprot.writeStructEnd()
19609 
 
19610 
  def validate(self):
19611 
    return
19612 
 
19613 
 
19614 
  def __repr__(self):
19615 
    L = ['%s=%r' % (key, value)
19616 
      for key, value in self.__dict__.iteritems()]
19617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19618 
 
19619 
  def __eq__(self, other):
19620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19621 
 
19622 
  def __ne__(self, other):
19623 
    return not (self == other)
19624 
 
19625 
class getInsurer_result:
19626 
  """
19627 
  Attributes:
19628 
   - success
19629 
  """
19630 
 
19631 
  thrift_spec = (
19632 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
19633 
  )
19634 
 
19635 
  def __init__(self, success=None,):
19636 
    self.success = success
19637 
 
19638 
  def read(self, iprot):
19639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19641 
      return
19642 
    iprot.readStructBegin()
19643 
    while True:
19644 
      (fname, ftype, fid) = iprot.readFieldBegin()
19645 
      if ftype == TType.STOP:
19646 
        break
19647 
      if fid == 0:
19648 
        if ftype == TType.STRUCT:
19649 
          self.success = Insurer()
19650 
          self.success.read(iprot)
19651 
        else:
19652 
          iprot.skip(ftype)
19653 
      else:
19654 
        iprot.skip(ftype)
19655 
      iprot.readFieldEnd()
19656 
    iprot.readStructEnd()
19657 
 
19658 
  def write(self, oprot):
19659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19661 
      return
19662 
    oprot.writeStructBegin('getInsurer_result')
19663 
    if self.success is not None:
19664 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19665 
      self.success.write(oprot)
19666 
      oprot.writeFieldEnd()
19667 
    oprot.writeFieldStop()
19668 
    oprot.writeStructEnd()
19669 
 
19670 
  def validate(self):
19671 
    return
19672 
 
19673 
 
19674 
  def __repr__(self):
19675 
    L = ['%s=%r' % (key, value)
19676 
      for key, value in self.__dict__.iteritems()]
19677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19678 
 
19679 
  def __eq__(self, other):
19680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19681 
 
19682 
  def __ne__(self, other):
19683 
    return not (self == other)
6838 vikram.rag 19684 
 
19685 
class getAllInsurers_args:
19686 
 
19687 
  thrift_spec = (
19688 
  )
19689 
 
19690 
  def read(self, iprot):
19691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19693 
      return
19694 
    iprot.readStructBegin()
19695 
    while True:
19696 
      (fname, ftype, fid) = iprot.readFieldBegin()
19697 
      if ftype == TType.STOP:
19698 
        break
19699 
      else:
19700 
        iprot.skip(ftype)
19701 
      iprot.readFieldEnd()
19702 
    iprot.readStructEnd()
19703 
 
19704 
  def write(self, oprot):
19705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19707 
      return
19708 
    oprot.writeStructBegin('getAllInsurers_args')
19709 
    oprot.writeFieldStop()
19710 
    oprot.writeStructEnd()
19711 
 
19712 
  def validate(self):
19713 
    return
19714 
 
19715 
 
19716 
  def __repr__(self):
19717 
    L = ['%s=%r' % (key, value)
19718 
      for key, value in self.__dict__.iteritems()]
19719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19720 
 
19721 
  def __eq__(self, other):
19722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19723 
 
19724 
  def __ne__(self, other):
19725 
    return not (self == other)
19726 
 
19727 
class getAllInsurers_result:
19728 
  """
19729 
  Attributes:
19730 
   - success
19731 
  """
19732 
 
19733 
  thrift_spec = (
19734 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
19735 
  )
19736 
 
19737 
  def __init__(self, success=None,):
19738 
    self.success = success
19739 
 
19740 
  def read(self, iprot):
19741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19743 
      return
19744 
    iprot.readStructBegin()
19745 
    while True:
19746 
      (fname, ftype, fid) = iprot.readFieldBegin()
19747 
      if ftype == TType.STOP:
19748 
        break
19749 
      if fid == 0:
19750 
        if ftype == TType.LIST:
19751 
          self.success = []
9155 kshitij.so 19752 
          (_etype384, _size381) = iprot.readListBegin()
19753 
          for _i385 in xrange(_size381):
19754 
            _elem386 = Insurer()
19755 
            _elem386.read(iprot)
19756 
            self.success.append(_elem386)
6838 vikram.rag 19757 
          iprot.readListEnd()
19758 
        else:
19759 
          iprot.skip(ftype)
19760 
      else:
19761 
        iprot.skip(ftype)
19762 
      iprot.readFieldEnd()
19763 
    iprot.readStructEnd()
19764 
 
19765 
  def write(self, oprot):
19766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19768 
      return
19769 
    oprot.writeStructBegin('getAllInsurers_result')
19770 
    if self.success is not None:
19771 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19772 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19773 
      for iter387 in self.success:
19774 
        iter387.write(oprot)
6838 vikram.rag 19775 
      oprot.writeListEnd()
19776 
      oprot.writeFieldEnd()
19777 
    oprot.writeFieldStop()
19778 
    oprot.writeStructEnd()
19779 
 
19780 
  def validate(self):
19781 
    return
19782 
 
19783 
 
19784 
  def __repr__(self):
19785 
    L = ['%s=%r' % (key, value)
19786 
      for key, value in self.__dict__.iteritems()]
19787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19788 
 
19789 
  def __eq__(self, other):
19790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19791 
 
19792 
  def __ne__(self, other):
19793 
    return not (self == other)
6962 rajveer 19794 
 
19795 
class updateInsuranceDeclaredAmount_args:
19796 
  """
19797 
  Attributes:
19798 
   - insurerId
19799 
   - amount
19800 
  """
19801 
 
19802 
  thrift_spec = (
19803 
    None, # 0
19804 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19805 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
19806 
  )
19807 
 
19808 
  def __init__(self, insurerId=None, amount=None,):
19809 
    self.insurerId = insurerId
19810 
    self.amount = amount
19811 
 
19812 
  def read(self, iprot):
19813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19815 
      return
19816 
    iprot.readStructBegin()
19817 
    while True:
19818 
      (fname, ftype, fid) = iprot.readFieldBegin()
19819 
      if ftype == TType.STOP:
19820 
        break
19821 
      if fid == 1:
19822 
        if ftype == TType.I64:
19823 
          self.insurerId = iprot.readI64();
19824 
        else:
19825 
          iprot.skip(ftype)
19826 
      elif fid == 2:
19827 
        if ftype == TType.DOUBLE:
19828 
          self.amount = iprot.readDouble();
19829 
        else:
19830 
          iprot.skip(ftype)
19831 
      else:
19832 
        iprot.skip(ftype)
19833 
      iprot.readFieldEnd()
19834 
    iprot.readStructEnd()
19835 
 
19836 
  def write(self, oprot):
19837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19839 
      return
19840 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
19841 
    if self.insurerId is not None:
19842 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19843 
      oprot.writeI64(self.insurerId)
19844 
      oprot.writeFieldEnd()
19845 
    if self.amount is not None:
19846 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
19847 
      oprot.writeDouble(self.amount)
19848 
      oprot.writeFieldEnd()
19849 
    oprot.writeFieldStop()
19850 
    oprot.writeStructEnd()
19851 
 
19852 
  def validate(self):
19853 
    return
19854 
 
19855 
 
19856 
  def __repr__(self):
19857 
    L = ['%s=%r' % (key, value)
19858 
      for key, value in self.__dict__.iteritems()]
19859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19860 
 
19861 
  def __eq__(self, other):
19862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19863 
 
19864 
  def __ne__(self, other):
19865 
    return not (self == other)
19866 
 
19867 
class updateInsuranceDeclaredAmount_result:
19868 
 
19869 
  thrift_spec = (
19870 
  )
19871 
 
19872 
  def read(self, iprot):
19873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19875 
      return
19876 
    iprot.readStructBegin()
19877 
    while True:
19878 
      (fname, ftype, fid) = iprot.readFieldBegin()
19879 
      if ftype == TType.STOP:
19880 
        break
19881 
      else:
19882 
        iprot.skip(ftype)
19883 
      iprot.readFieldEnd()
19884 
    iprot.readStructEnd()
19885 
 
19886 
  def write(self, oprot):
19887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19889 
      return
19890 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
19891 
    oprot.writeFieldStop()
19892 
    oprot.writeStructEnd()
19893 
 
19894 
  def validate(self):
19895 
    return
19896 
 
19897 
 
19898 
  def __repr__(self):
19899 
    L = ['%s=%r' % (key, value)
19900 
      for key, value in self.__dict__.iteritems()]
19901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19902 
 
19903 
  def __eq__(self, other):
19904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19905 
 
19906 
  def __ne__(self, other):
19907 
    return not (self == other)
7190 amar.kumar 19908 
 
19909 
class getFreebieForItem_args:
19910 
  """
19911 
  Attributes:
19912 
   - itemId
19913 
  """
19914 
 
19915 
  thrift_spec = (
19916 
    None, # 0
19917 
    (1, TType.I64, 'itemId', None, None, ), # 1
19918 
  )
19919 
 
19920 
  def __init__(self, itemId=None,):
19921 
    self.itemId = itemId
19922 
 
19923 
  def read(self, iprot):
19924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19926 
      return
19927 
    iprot.readStructBegin()
19928 
    while True:
19929 
      (fname, ftype, fid) = iprot.readFieldBegin()
19930 
      if ftype == TType.STOP:
19931 
        break
19932 
      if fid == 1:
19933 
        if ftype == TType.I64:
19934 
          self.itemId = iprot.readI64();
19935 
        else:
19936 
          iprot.skip(ftype)
19937 
      else:
19938 
        iprot.skip(ftype)
19939 
      iprot.readFieldEnd()
19940 
    iprot.readStructEnd()
19941 
 
19942 
  def write(self, oprot):
19943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19945 
      return
19946 
    oprot.writeStructBegin('getFreebieForItem_args')
19947 
    if self.itemId is not None:
19948 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19949 
      oprot.writeI64(self.itemId)
19950 
      oprot.writeFieldEnd()
19951 
    oprot.writeFieldStop()
19952 
    oprot.writeStructEnd()
19953 
 
19954 
  def validate(self):
19955 
    return
19956 
 
19957 
 
19958 
  def __repr__(self):
19959 
    L = ['%s=%r' % (key, value)
19960 
      for key, value in self.__dict__.iteritems()]
19961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19962 
 
19963 
  def __eq__(self, other):
19964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19965 
 
19966 
  def __ne__(self, other):
19967 
    return not (self == other)
19968 
 
19969 
class getFreebieForItem_result:
19970 
  """
19971 
  Attributes:
19972 
   - success
19973 
  """
19974 
 
19975 
  thrift_spec = (
19976 
    (0, TType.I64, 'success', None, None, ), # 0
19977 
  )
19978 
 
19979 
  def __init__(self, success=None,):
19980 
    self.success = success
19981 
 
19982 
  def read(self, iprot):
19983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19985 
      return
19986 
    iprot.readStructBegin()
19987 
    while True:
19988 
      (fname, ftype, fid) = iprot.readFieldBegin()
19989 
      if ftype == TType.STOP:
19990 
        break
19991 
      if fid == 0:
19992 
        if ftype == TType.I64:
19993 
          self.success = iprot.readI64();
19994 
        else:
19995 
          iprot.skip(ftype)
19996 
      else:
19997 
        iprot.skip(ftype)
19998 
      iprot.readFieldEnd()
19999 
    iprot.readStructEnd()
20000 
 
20001 
  def write(self, oprot):
20002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20004 
      return
20005 
    oprot.writeStructBegin('getFreebieForItem_result')
20006 
    if self.success is not None:
20007 
      oprot.writeFieldBegin('success', TType.I64, 0)
20008 
      oprot.writeI64(self.success)
20009 
      oprot.writeFieldEnd()
20010 
    oprot.writeFieldStop()
20011 
    oprot.writeStructEnd()
20012 
 
20013 
  def validate(self):
20014 
    return
20015 
 
20016 
 
20017 
  def __repr__(self):
20018 
    L = ['%s=%r' % (key, value)
20019 
      for key, value in self.__dict__.iteritems()]
20020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20021 
 
20022 
  def __eq__(self, other):
20023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20024 
 
20025 
  def __ne__(self, other):
20026 
    return not (self == other)
20027 
 
20028 
class addOrUpdateFreebieForItem_args:
20029 
  """
20030 
  Attributes:
20031 
   - freebieItem
20032 
  """
20033 
 
20034 
  thrift_spec = (
20035 
    None, # 0
20036 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
20037 
  )
20038 
 
20039 
  def __init__(self, freebieItem=None,):
20040 
    self.freebieItem = freebieItem
20041 
 
20042 
  def read(self, iprot):
20043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20045 
      return
20046 
    iprot.readStructBegin()
20047 
    while True:
20048 
      (fname, ftype, fid) = iprot.readFieldBegin()
20049 
      if ftype == TType.STOP:
20050 
        break
20051 
      if fid == 1:
20052 
        if ftype == TType.STRUCT:
20053 
          self.freebieItem = FreebieItem()
20054 
          self.freebieItem.read(iprot)
20055 
        else:
20056 
          iprot.skip(ftype)
20057 
      else:
20058 
        iprot.skip(ftype)
20059 
      iprot.readFieldEnd()
20060 
    iprot.readStructEnd()
20061 
 
20062 
  def write(self, oprot):
20063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20065 
      return
20066 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
20067 
    if self.freebieItem is not None:
20068 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
20069 
      self.freebieItem.write(oprot)
20070 
      oprot.writeFieldEnd()
20071 
    oprot.writeFieldStop()
20072 
    oprot.writeStructEnd()
20073 
 
20074 
  def validate(self):
20075 
    return
20076 
 
20077 
 
20078 
  def __repr__(self):
20079 
    L = ['%s=%r' % (key, value)
20080 
      for key, value in self.__dict__.iteritems()]
20081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20082 
 
20083 
  def __eq__(self, other):
20084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20085 
 
20086 
  def __ne__(self, other):
20087 
    return not (self == other)
20088 
 
20089 
class addOrUpdateFreebieForItem_result:
20090 
 
20091 
  thrift_spec = (
20092 
  )
20093 
 
20094 
  def read(self, iprot):
20095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20097 
      return
20098 
    iprot.readStructBegin()
20099 
    while True:
20100 
      (fname, ftype, fid) = iprot.readFieldBegin()
20101 
      if ftype == TType.STOP:
20102 
        break
20103 
      else:
20104 
        iprot.skip(ftype)
20105 
      iprot.readFieldEnd()
20106 
    iprot.readStructEnd()
20107 
 
20108 
  def write(self, oprot):
20109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20111 
      return
20112 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
20113 
    oprot.writeFieldStop()
20114 
    oprot.writeStructEnd()
20115 
 
20116 
  def validate(self):
20117 
    return
20118 
 
20119 
 
20120 
  def __repr__(self):
20121 
    L = ['%s=%r' % (key, value)
20122 
      for key, value in self.__dict__.iteritems()]
20123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20124 
 
20125 
  def __eq__(self, other):
20126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20127 
 
20128 
  def __ne__(self, other):
20129 
    return not (self == other)
7256 rajveer 20130 
 
7272 amit.gupta 20131 
class addOrUpdateBrandInfo_args:
20132 
  """
20133 
  Attributes:
20134 
   - brandInfo
20135 
  """
20136 
 
20137 
  thrift_spec = (
20138 
    None, # 0
20139 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
20140 
  )
20141 
 
20142 
  def __init__(self, brandInfo=None,):
20143 
    self.brandInfo = brandInfo
20144 
 
20145 
  def read(self, iprot):
20146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20148 
      return
20149 
    iprot.readStructBegin()
20150 
    while True:
20151 
      (fname, ftype, fid) = iprot.readFieldBegin()
20152 
      if ftype == TType.STOP:
20153 
        break
20154 
      if fid == 1:
20155 
        if ftype == TType.STRUCT:
20156 
          self.brandInfo = BrandInfo()
20157 
          self.brandInfo.read(iprot)
20158 
        else:
20159 
          iprot.skip(ftype)
20160 
      else:
20161 
        iprot.skip(ftype)
20162 
      iprot.readFieldEnd()
20163 
    iprot.readStructEnd()
20164 
 
20165 
  def write(self, oprot):
20166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20168 
      return
20169 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
20170 
    if self.brandInfo is not None:
20171 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
20172 
      self.brandInfo.write(oprot)
20173 
      oprot.writeFieldEnd()
20174 
    oprot.writeFieldStop()
20175 
    oprot.writeStructEnd()
20176 
 
20177 
  def validate(self):
20178 
    return
20179 
 
20180 
 
20181 
  def __repr__(self):
20182 
    L = ['%s=%r' % (key, value)
20183 
      for key, value in self.__dict__.iteritems()]
20184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20185 
 
20186 
  def __eq__(self, other):
20187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20188 
 
20189 
  def __ne__(self, other):
20190 
    return not (self == other)
20191 
 
20192 
class addOrUpdateBrandInfo_result:
20193 
 
20194 
  thrift_spec = (
20195 
  )
20196 
 
20197 
  def read(self, iprot):
20198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20200 
      return
20201 
    iprot.readStructBegin()
20202 
    while True:
20203 
      (fname, ftype, fid) = iprot.readFieldBegin()
20204 
      if ftype == TType.STOP:
20205 
        break
20206 
      else:
20207 
        iprot.skip(ftype)
20208 
      iprot.readFieldEnd()
20209 
    iprot.readStructEnd()
20210 
 
20211 
  def write(self, oprot):
20212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20214 
      return
20215 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
20216 
    oprot.writeFieldStop()
20217 
    oprot.writeStructEnd()
20218 
 
20219 
  def validate(self):
20220 
    return
20221 
 
20222 
 
20223 
  def __repr__(self):
20224 
    L = ['%s=%r' % (key, value)
20225 
      for key, value in self.__dict__.iteritems()]
20226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20227 
 
20228 
  def __eq__(self, other):
20229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20230 
 
20231 
  def __ne__(self, other):
20232 
    return not (self == other)
20233 
 
20234 
class getBrandInfo_args:
20235 
 
20236 
  thrift_spec = (
20237 
  )
20238 
 
20239 
  def read(self, iprot):
20240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20242 
      return
20243 
    iprot.readStructBegin()
20244 
    while True:
20245 
      (fname, ftype, fid) = iprot.readFieldBegin()
20246 
      if ftype == TType.STOP:
20247 
        break
20248 
      else:
20249 
        iprot.skip(ftype)
20250 
      iprot.readFieldEnd()
20251 
    iprot.readStructEnd()
20252 
 
20253 
  def write(self, oprot):
20254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20256 
      return
20257 
    oprot.writeStructBegin('getBrandInfo_args')
20258 
    oprot.writeFieldStop()
20259 
    oprot.writeStructEnd()
20260 
 
20261 
  def validate(self):
20262 
    return
20263 
 
20264 
 
20265 
  def __repr__(self):
20266 
    L = ['%s=%r' % (key, value)
20267 
      for key, value in self.__dict__.iteritems()]
20268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20269 
 
20270 
  def __eq__(self, other):
20271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20272 
 
20273 
  def __ne__(self, other):
20274 
    return not (self == other)
20275 
 
20276 
class getBrandInfo_result:
20277 
  """
20278 
  Attributes:
20279 
   - success
20280 
  """
20281 
 
20282 
  thrift_spec = (
20283 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
20284 
  )
20285 
 
20286 
  def __init__(self, success=None,):
20287 
    self.success = success
20288 
 
20289 
  def read(self, iprot):
20290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20292 
      return
20293 
    iprot.readStructBegin()
20294 
    while True:
20295 
      (fname, ftype, fid) = iprot.readFieldBegin()
20296 
      if ftype == TType.STOP:
20297 
        break
20298 
      if fid == 0:
20299 
        if ftype == TType.MAP:
20300 
          self.success = {}
9155 kshitij.so 20301 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
20302 
          for _i392 in xrange(_size388):
20303 
            _key393 = iprot.readString();
20304 
            _val394 = BrandInfo()
20305 
            _val394.read(iprot)
20306 
            self.success[_key393] = _val394
7272 amit.gupta 20307 
          iprot.readMapEnd()
20308 
        else:
20309 
          iprot.skip(ftype)
20310 
      else:
20311 
        iprot.skip(ftype)
20312 
      iprot.readFieldEnd()
20313 
    iprot.readStructEnd()
20314 
 
20315 
  def write(self, oprot):
20316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20318 
      return
20319 
    oprot.writeStructBegin('getBrandInfo_result')
20320 
    if self.success is not None:
20321 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20322 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 20323 
      for kiter395,viter396 in self.success.items():
20324 
        oprot.writeString(kiter395)
20325 
        viter396.write(oprot)
7272 amit.gupta 20326 
      oprot.writeMapEnd()
20327 
      oprot.writeFieldEnd()
20328 
    oprot.writeFieldStop()
20329 
    oprot.writeStructEnd()
20330 
 
20331 
  def validate(self):
20332 
    return
20333 
 
20334 
 
20335 
  def __repr__(self):
20336 
    L = ['%s=%r' % (key, value)
20337 
      for key, value in self.__dict__.iteritems()]
20338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20339 
 
20340 
  def __eq__(self, other):
20341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20342 
 
20343 
  def __ne__(self, other):
20344 
    return not (self == other)
20345 
 
7256 rajveer 20346 
class getStorePricing_args:
20347 
  """
20348 
  Attributes:
20349 
   - itemId
20350 
  """
20351 
 
20352 
  thrift_spec = (
20353 
    None, # 0
20354 
    (1, TType.I64, 'itemId', None, None, ), # 1
20355 
  )
20356 
 
20357 
  def __init__(self, itemId=None,):
20358 
    self.itemId = itemId
20359 
 
20360 
  def read(self, iprot):
20361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20363 
      return
20364 
    iprot.readStructBegin()
20365 
    while True:
20366 
      (fname, ftype, fid) = iprot.readFieldBegin()
20367 
      if ftype == TType.STOP:
20368 
        break
20369 
      if fid == 1:
20370 
        if ftype == TType.I64:
20371 
          self.itemId = iprot.readI64();
20372 
        else:
20373 
          iprot.skip(ftype)
20374 
      else:
20375 
        iprot.skip(ftype)
20376 
      iprot.readFieldEnd()
20377 
    iprot.readStructEnd()
20378 
 
20379 
  def write(self, oprot):
20380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20382 
      return
20383 
    oprot.writeStructBegin('getStorePricing_args')
20384 
    if self.itemId is not None:
20385 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20386 
      oprot.writeI64(self.itemId)
20387 
      oprot.writeFieldEnd()
20388 
    oprot.writeFieldStop()
20389 
    oprot.writeStructEnd()
20390 
 
20391 
  def validate(self):
20392 
    return
20393 
 
20394 
 
20395 
  def __repr__(self):
20396 
    L = ['%s=%r' % (key, value)
20397 
      for key, value in self.__dict__.iteritems()]
20398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20399 
 
20400 
  def __eq__(self, other):
20401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20402 
 
20403 
  def __ne__(self, other):
20404 
    return not (self == other)
20405 
 
20406 
class getStorePricing_result:
20407 
  """
20408 
  Attributes:
20409 
   - success
20410 
  """
20411 
 
20412 
  thrift_spec = (
20413 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
20414 
  )
20415 
 
20416 
  def __init__(self, success=None,):
20417 
    self.success = success
20418 
 
20419 
  def read(self, iprot):
20420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20422 
      return
20423 
    iprot.readStructBegin()
20424 
    while True:
20425 
      (fname, ftype, fid) = iprot.readFieldBegin()
20426 
      if ftype == TType.STOP:
20427 
        break
20428 
      if fid == 0:
20429 
        if ftype == TType.STRUCT:
20430 
          self.success = StorePricing()
20431 
          self.success.read(iprot)
20432 
        else:
20433 
          iprot.skip(ftype)
20434 
      else:
20435 
        iprot.skip(ftype)
20436 
      iprot.readFieldEnd()
20437 
    iprot.readStructEnd()
20438 
 
20439 
  def write(self, oprot):
20440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20442 
      return
20443 
    oprot.writeStructBegin('getStorePricing_result')
20444 
    if self.success is not None:
20445 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20446 
      self.success.write(oprot)
20447 
      oprot.writeFieldEnd()
20448 
    oprot.writeFieldStop()
20449 
    oprot.writeStructEnd()
20450 
 
20451 
  def validate(self):
20452 
    return
20453 
 
20454 
 
20455 
  def __repr__(self):
20456 
    L = ['%s=%r' % (key, value)
20457 
      for key, value in self.__dict__.iteritems()]
20458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20459 
 
20460 
  def __eq__(self, other):
20461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20462 
 
20463 
  def __ne__(self, other):
20464 
    return not (self == other)
7265 rajveer 20465 
 
7306 rajveer 20466 
class getStorePricings_args:
20467 
  """
20468 
  Attributes:
20469 
   - itemIds
20470 
  """
20471 
 
20472 
  thrift_spec = (
20473 
    None, # 0
20474 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20475 
  )
20476 
 
20477 
  def __init__(self, itemIds=None,):
20478 
    self.itemIds = itemIds
20479 
 
20480 
  def read(self, iprot):
20481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20483 
      return
20484 
    iprot.readStructBegin()
20485 
    while True:
20486 
      (fname, ftype, fid) = iprot.readFieldBegin()
20487 
      if ftype == TType.STOP:
20488 
        break
20489 
      if fid == 1:
20490 
        if ftype == TType.LIST:
20491 
          self.itemIds = []
9155 kshitij.so 20492 
          (_etype400, _size397) = iprot.readListBegin()
20493 
          for _i401 in xrange(_size397):
20494 
            _elem402 = iprot.readI64();
20495 
            self.itemIds.append(_elem402)
7306 rajveer 20496 
          iprot.readListEnd()
20497 
        else:
20498 
          iprot.skip(ftype)
20499 
      else:
20500 
        iprot.skip(ftype)
20501 
      iprot.readFieldEnd()
20502 
    iprot.readStructEnd()
20503 
 
20504 
  def write(self, oprot):
20505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20507 
      return
20508 
    oprot.writeStructBegin('getStorePricings_args')
20509 
    if self.itemIds is not None:
20510 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20511 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 20512 
      for iter403 in self.itemIds:
20513 
        oprot.writeI64(iter403)
7306 rajveer 20514 
      oprot.writeListEnd()
20515 
      oprot.writeFieldEnd()
20516 
    oprot.writeFieldStop()
20517 
    oprot.writeStructEnd()
20518 
 
20519 
  def validate(self):
20520 
    return
20521 
 
20522 
 
20523 
  def __repr__(self):
20524 
    L = ['%s=%r' % (key, value)
20525 
      for key, value in self.__dict__.iteritems()]
20526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20527 
 
20528 
  def __eq__(self, other):
20529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20530 
 
20531 
  def __ne__(self, other):
20532 
    return not (self == other)
20533 
 
20534 
class getStorePricings_result:
20535 
  """
20536 
  Attributes:
20537 
   - success
20538 
  """
20539 
 
20540 
  thrift_spec = (
20541 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
20542 
  )
20543 
 
20544 
  def __init__(self, success=None,):
20545 
    self.success = success
20546 
 
20547 
  def read(self, iprot):
20548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20550 
      return
20551 
    iprot.readStructBegin()
20552 
    while True:
20553 
      (fname, ftype, fid) = iprot.readFieldBegin()
20554 
      if ftype == TType.STOP:
20555 
        break
20556 
      if fid == 0:
20557 
        if ftype == TType.LIST:
20558 
          self.success = []
9155 kshitij.so 20559 
          (_etype407, _size404) = iprot.readListBegin()
20560 
          for _i408 in xrange(_size404):
20561 
            _elem409 = StorePricing()
20562 
            _elem409.read(iprot)
20563 
            self.success.append(_elem409)
7306 rajveer 20564 
          iprot.readListEnd()
20565 
        else:
20566 
          iprot.skip(ftype)
20567 
      else:
20568 
        iprot.skip(ftype)
20569 
      iprot.readFieldEnd()
20570 
    iprot.readStructEnd()
20571 
 
20572 
  def write(self, oprot):
20573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20575 
      return
20576 
    oprot.writeStructBegin('getStorePricings_result')
20577 
    if self.success is not None:
20578 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20579 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20580 
      for iter410 in self.success:
20581 
        iter410.write(oprot)
7306 rajveer 20582 
      oprot.writeListEnd()
20583 
      oprot.writeFieldEnd()
20584 
    oprot.writeFieldStop()
20585 
    oprot.writeStructEnd()
20586 
 
20587 
  def validate(self):
20588 
    return
20589 
 
20590 
 
20591 
  def __repr__(self):
20592 
    L = ['%s=%r' % (key, value)
20593 
      for key, value in self.__dict__.iteritems()]
20594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20595 
 
20596 
  def __eq__(self, other):
20597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20598 
 
20599 
  def __ne__(self, other):
20600 
    return not (self == other)
20601 
 
7265 rajveer 20602 
class updateStorePricing_args:
20603 
  """
20604 
  Attributes:
20605 
   - sp
7382 rajveer 20606 
   - allColors
7265 rajveer 20607 
  """
20608 
 
20609 
  thrift_spec = (
20610 
    None, # 0
20611 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 20612 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 20613 
  )
20614 
 
7382 rajveer 20615 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 20616 
    self.sp = sp
7382 rajveer 20617 
    self.allColors = allColors
7265 rajveer 20618 
 
20619 
  def read(self, iprot):
20620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20622 
      return
20623 
    iprot.readStructBegin()
20624 
    while True:
20625 
      (fname, ftype, fid) = iprot.readFieldBegin()
20626 
      if ftype == TType.STOP:
20627 
        break
20628 
      if fid == 1:
20629 
        if ftype == TType.STRUCT:
20630 
          self.sp = StorePricing()
20631 
          self.sp.read(iprot)
20632 
        else:
20633 
          iprot.skip(ftype)
7382 rajveer 20634 
      elif fid == 2:
20635 
        if ftype == TType.BOOL:
20636 
          self.allColors = iprot.readBool();
20637 
        else:
20638 
          iprot.skip(ftype)
7265 rajveer 20639 
      else:
20640 
        iprot.skip(ftype)
20641 
      iprot.readFieldEnd()
20642 
    iprot.readStructEnd()
20643 
 
20644 
  def write(self, oprot):
20645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20647 
      return
20648 
    oprot.writeStructBegin('updateStorePricing_args')
20649 
    if self.sp is not None:
20650 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
20651 
      self.sp.write(oprot)
20652 
      oprot.writeFieldEnd()
7382 rajveer 20653 
    if self.allColors is not None:
20654 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
20655 
      oprot.writeBool(self.allColors)
20656 
      oprot.writeFieldEnd()
7265 rajveer 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 updateStorePricing_result:
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('updateStorePricing_result')
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)
7281 kshitij.so 20716 
 
20717 
class getAllAmazonListedItems_args:
20718 
 
20719 
  thrift_spec = (
20720 
  )
20721 
 
20722 
  def read(self, iprot):
20723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20725 
      return
20726 
    iprot.readStructBegin()
20727 
    while True:
20728 
      (fname, ftype, fid) = iprot.readFieldBegin()
20729 
      if ftype == TType.STOP:
20730 
        break
20731 
      else:
20732 
        iprot.skip(ftype)
20733 
      iprot.readFieldEnd()
20734 
    iprot.readStructEnd()
20735 
 
20736 
  def write(self, oprot):
20737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20739 
      return
20740 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
20741 
    oprot.writeFieldStop()
20742 
    oprot.writeStructEnd()
20743 
 
20744 
  def validate(self):
20745 
    return
20746 
 
20747 
 
20748 
  def __repr__(self):
20749 
    L = ['%s=%r' % (key, value)
20750 
      for key, value in self.__dict__.iteritems()]
20751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20752 
 
20753 
  def __eq__(self, other):
20754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20755 
 
20756 
  def __ne__(self, other):
20757 
    return not (self == other)
20758 
 
20759 
class getAllAmazonListedItems_result:
20760 
  """
20761 
  Attributes:
20762 
   - success
20763 
  """
20764 
 
20765 
  thrift_spec = (
20766 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20767 
  )
20768 
 
20769 
  def __init__(self, success=None,):
20770 
    self.success = success
20771 
 
20772 
  def read(self, iprot):
20773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20775 
      return
20776 
    iprot.readStructBegin()
20777 
    while True:
20778 
      (fname, ftype, fid) = iprot.readFieldBegin()
20779 
      if ftype == TType.STOP:
20780 
        break
20781 
      if fid == 0:
20782 
        if ftype == TType.LIST:
20783 
          self.success = []
9155 kshitij.so 20784 
          (_etype414, _size411) = iprot.readListBegin()
20785 
          for _i415 in xrange(_size411):
20786 
            _elem416 = Amazonlisted()
20787 
            _elem416.read(iprot)
20788 
            self.success.append(_elem416)
7281 kshitij.so 20789 
          iprot.readListEnd()
20790 
        else:
20791 
          iprot.skip(ftype)
20792 
      else:
20793 
        iprot.skip(ftype)
20794 
      iprot.readFieldEnd()
20795 
    iprot.readStructEnd()
20796 
 
20797 
  def write(self, oprot):
20798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20800 
      return
20801 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
20802 
    if self.success is not None:
20803 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20804 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20805 
      for iter417 in self.success:
20806 
        iter417.write(oprot)
7281 kshitij.so 20807 
      oprot.writeListEnd()
20808 
      oprot.writeFieldEnd()
20809 
    oprot.writeFieldStop()
20810 
    oprot.writeStructEnd()
20811 
 
20812 
  def validate(self):
20813 
    return
20814 
 
20815 
 
20816 
  def __repr__(self):
20817 
    L = ['%s=%r' % (key, value)
20818 
      for key, value in self.__dict__.iteritems()]
20819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20820 
 
20821 
  def __eq__(self, other):
20822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20823 
 
20824 
  def __ne__(self, other):
20825 
    return not (self == other)
20826 
 
8619 kshitij.so 20827 
class searchAmazonItems_args:
20828 
  """
20829 
  Attributes:
20830 
   - searchTerm
20831 
   - offset
20832 
   - limit
20833 
  """
20834 
 
20835 
  thrift_spec = (
20836 
    None, # 0
20837 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20838 
    (2, TType.I64, 'offset', None, None, ), # 2
20839 
    (3, TType.I64, 'limit', None, None, ), # 3
20840 
  )
20841 
 
20842 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
20843 
    self.searchTerm = searchTerm
20844 
    self.offset = offset
20845 
    self.limit = limit
20846 
 
20847 
  def read(self, iprot):
20848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20850 
      return
20851 
    iprot.readStructBegin()
20852 
    while True:
20853 
      (fname, ftype, fid) = iprot.readFieldBegin()
20854 
      if ftype == TType.STOP:
20855 
        break
20856 
      if fid == 1:
20857 
        if ftype == TType.LIST:
20858 
          self.searchTerm = []
9155 kshitij.so 20859 
          (_etype421, _size418) = iprot.readListBegin()
20860 
          for _i422 in xrange(_size418):
20861 
            _elem423 = iprot.readString();
20862 
            self.searchTerm.append(_elem423)
8619 kshitij.so 20863 
          iprot.readListEnd()
20864 
        else:
20865 
          iprot.skip(ftype)
20866 
      elif fid == 2:
20867 
        if ftype == TType.I64:
20868 
          self.offset = iprot.readI64();
20869 
        else:
20870 
          iprot.skip(ftype)
20871 
      elif fid == 3:
20872 
        if ftype == TType.I64:
20873 
          self.limit = iprot.readI64();
20874 
        else:
20875 
          iprot.skip(ftype)
20876 
      else:
20877 
        iprot.skip(ftype)
20878 
      iprot.readFieldEnd()
20879 
    iprot.readStructEnd()
20880 
 
20881 
  def write(self, oprot):
20882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20884 
      return
20885 
    oprot.writeStructBegin('searchAmazonItems_args')
20886 
    if self.searchTerm is not None:
20887 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20888 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20889 
      for iter424 in self.searchTerm:
20890 
        oprot.writeString(iter424)
8619 kshitij.so 20891 
      oprot.writeListEnd()
20892 
      oprot.writeFieldEnd()
20893 
    if self.offset is not None:
20894 
      oprot.writeFieldBegin('offset', TType.I64, 2)
20895 
      oprot.writeI64(self.offset)
20896 
      oprot.writeFieldEnd()
20897 
    if self.limit is not None:
20898 
      oprot.writeFieldBegin('limit', TType.I64, 3)
20899 
      oprot.writeI64(self.limit)
20900 
      oprot.writeFieldEnd()
20901 
    oprot.writeFieldStop()
20902 
    oprot.writeStructEnd()
20903 
 
20904 
  def validate(self):
20905 
    return
20906 
 
20907 
 
20908 
  def __repr__(self):
20909 
    L = ['%s=%r' % (key, value)
20910 
      for key, value in self.__dict__.iteritems()]
20911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20912 
 
20913 
  def __eq__(self, other):
20914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20915 
 
20916 
  def __ne__(self, other):
20917 
    return not (self == other)
20918 
 
20919 
class searchAmazonItems_result:
20920 
  """
20921 
  Attributes:
20922 
   - success
20923 
  """
20924 
 
20925 
  thrift_spec = (
20926 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20927 
  )
20928 
 
20929 
  def __init__(self, success=None,):
20930 
    self.success = success
20931 
 
20932 
  def read(self, iprot):
20933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20935 
      return
20936 
    iprot.readStructBegin()
20937 
    while True:
20938 
      (fname, ftype, fid) = iprot.readFieldBegin()
20939 
      if ftype == TType.STOP:
20940 
        break
20941 
      if fid == 0:
20942 
        if ftype == TType.LIST:
20943 
          self.success = []
9155 kshitij.so 20944 
          (_etype428, _size425) = iprot.readListBegin()
20945 
          for _i429 in xrange(_size425):
20946 
            _elem430 = Amazonlisted()
20947 
            _elem430.read(iprot)
20948 
            self.success.append(_elem430)
8619 kshitij.so 20949 
          iprot.readListEnd()
20950 
        else:
20951 
          iprot.skip(ftype)
20952 
      else:
20953 
        iprot.skip(ftype)
20954 
      iprot.readFieldEnd()
20955 
    iprot.readStructEnd()
20956 
 
20957 
  def write(self, oprot):
20958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20960 
      return
20961 
    oprot.writeStructBegin('searchAmazonItems_result')
20962 
    if self.success is not None:
20963 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20964 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20965 
      for iter431 in self.success:
20966 
        iter431.write(oprot)
8619 kshitij.so 20967 
      oprot.writeListEnd()
20968 
      oprot.writeFieldEnd()
20969 
    oprot.writeFieldStop()
20970 
    oprot.writeStructEnd()
20971 
 
20972 
  def validate(self):
20973 
    return
20974 
 
20975 
 
20976 
  def __repr__(self):
20977 
    L = ['%s=%r' % (key, value)
20978 
      for key, value in self.__dict__.iteritems()]
20979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20980 
 
20981 
  def __eq__(self, other):
20982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20983 
 
20984 
  def __ne__(self, other):
20985 
    return not (self == other)
20986 
 
20987 
class getAmazonSearchResultCount_args:
20988 
  """
20989 
  Attributes:
20990 
   - searchTerm
20991 
  """
20992 
 
20993 
  thrift_spec = (
20994 
    None, # 0
20995 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20996 
  )
20997 
 
20998 
  def __init__(self, searchTerm=None,):
20999 
    self.searchTerm = searchTerm
21000 
 
21001 
  def read(self, iprot):
21002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21004 
      return
21005 
    iprot.readStructBegin()
21006 
    while True:
21007 
      (fname, ftype, fid) = iprot.readFieldBegin()
21008 
      if ftype == TType.STOP:
21009 
        break
21010 
      if fid == 1:
21011 
        if ftype == TType.LIST:
21012 
          self.searchTerm = []
9155 kshitij.so 21013 
          (_etype435, _size432) = iprot.readListBegin()
21014 
          for _i436 in xrange(_size432):
21015 
            _elem437 = iprot.readString();
21016 
            self.searchTerm.append(_elem437)
8619 kshitij.so 21017 
          iprot.readListEnd()
21018 
        else:
21019 
          iprot.skip(ftype)
21020 
      else:
21021 
        iprot.skip(ftype)
21022 
      iprot.readFieldEnd()
21023 
    iprot.readStructEnd()
21024 
 
21025 
  def write(self, oprot):
21026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21028 
      return
21029 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
21030 
    if self.searchTerm is not None:
21031 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
21032 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 21033 
      for iter438 in self.searchTerm:
21034 
        oprot.writeString(iter438)
8619 kshitij.so 21035 
      oprot.writeListEnd()
21036 
      oprot.writeFieldEnd()
21037 
    oprot.writeFieldStop()
21038 
    oprot.writeStructEnd()
21039 
 
21040 
  def validate(self):
21041 
    return
21042 
 
21043 
 
21044 
  def __repr__(self):
21045 
    L = ['%s=%r' % (key, value)
21046 
      for key, value in self.__dict__.iteritems()]
21047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21048 
 
21049 
  def __eq__(self, other):
21050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21051 
 
21052 
  def __ne__(self, other):
21053 
    return not (self == other)
21054 
 
21055 
class getAmazonSearchResultCount_result:
21056 
  """
21057 
  Attributes:
21058 
   - success
21059 
  """
21060 
 
21061 
  thrift_spec = (
21062 
    (0, TType.I64, 'success', None, None, ), # 0
21063 
  )
21064 
 
21065 
  def __init__(self, success=None,):
21066 
    self.success = success
21067 
 
21068 
  def read(self, iprot):
21069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21071 
      return
21072 
    iprot.readStructBegin()
21073 
    while True:
21074 
      (fname, ftype, fid) = iprot.readFieldBegin()
21075 
      if ftype == TType.STOP:
21076 
        break
21077 
      if fid == 0:
21078 
        if ftype == TType.I64:
21079 
          self.success = iprot.readI64();
21080 
        else:
21081 
          iprot.skip(ftype)
21082 
      else:
21083 
        iprot.skip(ftype)
21084 
      iprot.readFieldEnd()
21085 
    iprot.readStructEnd()
21086 
 
21087 
  def write(self, oprot):
21088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21090 
      return
21091 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
21092 
    if self.success is not None:
21093 
      oprot.writeFieldBegin('success', TType.I64, 0)
21094 
      oprot.writeI64(self.success)
21095 
      oprot.writeFieldEnd()
21096 
    oprot.writeFieldStop()
21097 
    oprot.writeStructEnd()
21098 
 
21099 
  def validate(self):
21100 
    return
21101 
 
21102 
 
21103 
  def __repr__(self):
21104 
    L = ['%s=%r' % (key, value)
21105 
      for key, value in self.__dict__.iteritems()]
21106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21107 
 
21108 
  def __eq__(self, other):
21109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21110 
 
21111 
  def __ne__(self, other):
21112 
    return not (self == other)
21113 
 
21114 
class getCountForAmazonlistedItems_args:
21115 
 
21116 
  thrift_spec = (
21117 
  )
21118 
 
21119 
  def read(self, iprot):
21120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21122 
      return
21123 
    iprot.readStructBegin()
21124 
    while True:
21125 
      (fname, ftype, fid) = iprot.readFieldBegin()
21126 
      if ftype == TType.STOP:
21127 
        break
21128 
      else:
21129 
        iprot.skip(ftype)
21130 
      iprot.readFieldEnd()
21131 
    iprot.readStructEnd()
21132 
 
21133 
  def write(self, oprot):
21134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21136 
      return
21137 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
21138 
    oprot.writeFieldStop()
21139 
    oprot.writeStructEnd()
21140 
 
21141 
  def validate(self):
21142 
    return
21143 
 
21144 
 
21145 
  def __repr__(self):
21146 
    L = ['%s=%r' % (key, value)
21147 
      for key, value in self.__dict__.iteritems()]
21148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21149 
 
21150 
  def __eq__(self, other):
21151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21152 
 
21153 
  def __ne__(self, other):
21154 
    return not (self == other)
21155 
 
21156 
class getCountForAmazonlistedItems_result:
21157 
  """
21158 
  Attributes:
21159 
   - success
21160 
  """
21161 
 
21162 
  thrift_spec = (
21163 
    (0, TType.I64, 'success', None, None, ), # 0
21164 
  )
21165 
 
21166 
  def __init__(self, success=None,):
21167 
    self.success = success
21168 
 
21169 
  def read(self, iprot):
21170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21172 
      return
21173 
    iprot.readStructBegin()
21174 
    while True:
21175 
      (fname, ftype, fid) = iprot.readFieldBegin()
21176 
      if ftype == TType.STOP:
21177 
        break
21178 
      if fid == 0:
21179 
        if ftype == TType.I64:
21180 
          self.success = iprot.readI64();
21181 
        else:
21182 
          iprot.skip(ftype)
21183 
      else:
21184 
        iprot.skip(ftype)
21185 
      iprot.readFieldEnd()
21186 
    iprot.readStructEnd()
21187 
 
21188 
  def write(self, oprot):
21189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21191 
      return
21192 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
21193 
    if self.success is not None:
21194 
      oprot.writeFieldBegin('success', TType.I64, 0)
21195 
      oprot.writeI64(self.success)
21196 
      oprot.writeFieldEnd()
21197 
    oprot.writeFieldStop()
21198 
    oprot.writeStructEnd()
21199 
 
21200 
  def validate(self):
21201 
    return
21202 
 
21203 
 
21204 
  def __repr__(self):
21205 
    L = ['%s=%r' % (key, value)
21206 
      for key, value in self.__dict__.iteritems()]
21207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21208 
 
21209 
  def __eq__(self, other):
21210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21211 
 
21212 
  def __ne__(self, other):
21213 
    return not (self == other)
21214 
 
7281 kshitij.so 21215 
class getAmazonItemDetails_args:
21216 
  """
21217 
  Attributes:
21218 
   - itemId
21219 
  """
21220 
 
21221 
  thrift_spec = (
21222 
    None, # 0
21223 
    (1, TType.I64, 'itemId', None, None, ), # 1
21224 
  )
21225 
 
21226 
  def __init__(self, itemId=None,):
21227 
    self.itemId = itemId
21228 
 
21229 
  def read(self, iprot):
21230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21232 
      return
21233 
    iprot.readStructBegin()
21234 
    while True:
21235 
      (fname, ftype, fid) = iprot.readFieldBegin()
21236 
      if ftype == TType.STOP:
21237 
        break
21238 
      if fid == 1:
21239 
        if ftype == TType.I64:
21240 
          self.itemId = iprot.readI64();
21241 
        else:
21242 
          iprot.skip(ftype)
21243 
      else:
21244 
        iprot.skip(ftype)
21245 
      iprot.readFieldEnd()
21246 
    iprot.readStructEnd()
21247 
 
21248 
  def write(self, oprot):
21249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21251 
      return
21252 
    oprot.writeStructBegin('getAmazonItemDetails_args')
21253 
    if self.itemId is not None:
21254 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21255 
      oprot.writeI64(self.itemId)
21256 
      oprot.writeFieldEnd()
21257 
    oprot.writeFieldStop()
21258 
    oprot.writeStructEnd()
21259 
 
21260 
  def validate(self):
21261 
    return
21262 
 
21263 
 
21264 
  def __repr__(self):
21265 
    L = ['%s=%r' % (key, value)
21266 
      for key, value in self.__dict__.iteritems()]
21267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21268 
 
21269 
  def __eq__(self, other):
21270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21271 
 
21272 
  def __ne__(self, other):
21273 
    return not (self == other)
21274 
 
21275 
class getAmazonItemDetails_result:
21276 
  """
21277 
  Attributes:
21278 
   - success
21279 
  """
21280 
 
21281 
  thrift_spec = (
21282 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
21283 
  )
21284 
 
21285 
  def __init__(self, success=None,):
21286 
    self.success = success
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 == 0:
21298 
        if ftype == TType.STRUCT:
21299 
          self.success = Amazonlisted()
21300 
          self.success.read(iprot)
21301 
        else:
21302 
          iprot.skip(ftype)
21303 
      else:
21304 
        iprot.skip(ftype)
21305 
      iprot.readFieldEnd()
21306 
    iprot.readStructEnd()
21307 
 
21308 
  def write(self, oprot):
21309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21311 
      return
21312 
    oprot.writeStructBegin('getAmazonItemDetails_result')
21313 
    if self.success is not None:
21314 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21315 
      self.success.write(oprot)
21316 
      oprot.writeFieldEnd()
21317 
    oprot.writeFieldStop()
21318 
    oprot.writeStructEnd()
21319 
 
21320 
  def validate(self):
21321 
    return
21322 
 
21323 
 
21324 
  def __repr__(self):
21325 
    L = ['%s=%r' % (key, value)
21326 
      for key, value in self.__dict__.iteritems()]
21327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21328 
 
21329 
  def __eq__(self, other):
21330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21331 
 
21332 
  def __ne__(self, other):
21333 
    return not (self == other)
21334 
 
21335 
class updateAmazonItemDetails_args:
21336 
  """
21337 
  Attributes:
8168 kshitij.so 21338 
   - amazonlisted
7281 kshitij.so 21339 
  """
21340 
 
21341 
  thrift_spec = (
21342 
    None, # 0
8168 kshitij.so 21343 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 21344 
  )
21345 
 
8168 kshitij.so 21346 
  def __init__(self, amazonlisted=None,):
21347 
    self.amazonlisted = amazonlisted
7281 kshitij.so 21348 
 
21349 
  def read(self, iprot):
21350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21352 
      return
21353 
    iprot.readStructBegin()
21354 
    while True:
21355 
      (fname, ftype, fid) = iprot.readFieldBegin()
21356 
      if ftype == TType.STOP:
21357 
        break
21358 
      if fid == 1:
8168 kshitij.so 21359 
        if ftype == TType.STRUCT:
21360 
          self.amazonlisted = Amazonlisted()
21361 
          self.amazonlisted.read(iprot)
7281 kshitij.so 21362 
        else:
21363 
          iprot.skip(ftype)
21364 
      else:
21365 
        iprot.skip(ftype)
21366 
      iprot.readFieldEnd()
21367 
    iprot.readStructEnd()
21368 
 
21369 
  def write(self, oprot):
21370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21372 
      return
21373 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 21374 
    if self.amazonlisted is not None:
21375 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
21376 
      self.amazonlisted.write(oprot)
7281 kshitij.so 21377 
      oprot.writeFieldEnd()
21378 
    oprot.writeFieldStop()
21379 
    oprot.writeStructEnd()
21380 
 
21381 
  def validate(self):
21382 
    return
21383 
 
21384 
 
21385 
  def __repr__(self):
21386 
    L = ['%s=%r' % (key, value)
21387 
      for key, value in self.__dict__.iteritems()]
21388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21389 
 
21390 
  def __eq__(self, other):
21391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21392 
 
21393 
  def __ne__(self, other):
21394 
    return not (self == other)
21395 
 
21396 
class updateAmazonItemDetails_result:
21397 
 
21398 
  thrift_spec = (
21399 
  )
21400 
 
21401 
  def read(self, iprot):
21402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21404 
      return
21405 
    iprot.readStructBegin()
21406 
    while True:
21407 
      (fname, ftype, fid) = iprot.readFieldBegin()
21408 
      if ftype == TType.STOP:
21409 
        break
21410 
      else:
21411 
        iprot.skip(ftype)
21412 
      iprot.readFieldEnd()
21413 
    iprot.readStructEnd()
21414 
 
21415 
  def write(self, oprot):
21416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21418 
      return
21419 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
21420 
    oprot.writeFieldStop()
21421 
    oprot.writeStructEnd()
21422 
 
21423 
  def validate(self):
21424 
    return
21425 
 
21426 
 
21427 
  def __repr__(self):
21428 
    L = ['%s=%r' % (key, value)
21429 
      for key, value in self.__dict__.iteritems()]
21430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21431 
 
21432 
  def __eq__(self, other):
21433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21434 
 
21435 
  def __ne__(self, other):
21436 
    return not (self == other)
21437 
 
21438 
class addAmazonItem_args:
21439 
  """
21440 
  Attributes:
21441 
   - amazonlisted
21442 
  """
21443 
 
21444 
  thrift_spec = (
21445 
    None, # 0
21446 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
21447 
  )
21448 
 
21449 
  def __init__(self, amazonlisted=None,):
21450 
    self.amazonlisted = amazonlisted
21451 
 
21452 
  def read(self, iprot):
21453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21455 
      return
21456 
    iprot.readStructBegin()
21457 
    while True:
21458 
      (fname, ftype, fid) = iprot.readFieldBegin()
21459 
      if ftype == TType.STOP:
21460 
        break
21461 
      if fid == 1:
21462 
        if ftype == TType.STRUCT:
21463 
          self.amazonlisted = Amazonlisted()
21464 
          self.amazonlisted.read(iprot)
21465 
        else:
21466 
          iprot.skip(ftype)
21467 
      else:
21468 
        iprot.skip(ftype)
21469 
      iprot.readFieldEnd()
21470 
    iprot.readStructEnd()
21471 
 
21472 
  def write(self, oprot):
21473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21475 
      return
21476 
    oprot.writeStructBegin('addAmazonItem_args')
21477 
    if self.amazonlisted is not None:
21478 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
21479 
      self.amazonlisted.write(oprot)
21480 
      oprot.writeFieldEnd()
21481 
    oprot.writeFieldStop()
21482 
    oprot.writeStructEnd()
21483 
 
21484 
  def validate(self):
21485 
    return
21486 
 
21487 
 
21488 
  def __repr__(self):
21489 
    L = ['%s=%r' % (key, value)
21490 
      for key, value in self.__dict__.iteritems()]
21491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21492 
 
21493 
  def __eq__(self, other):
21494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21495 
 
21496 
  def __ne__(self, other):
21497 
    return not (self == other)
21498 
 
21499 
class addAmazonItem_result:
21500 
 
21501 
  thrift_spec = (
21502 
  )
21503 
 
21504 
  def read(self, iprot):
21505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21507 
      return
21508 
    iprot.readStructBegin()
21509 
    while True:
21510 
      (fname, ftype, fid) = iprot.readFieldBegin()
21511 
      if ftype == TType.STOP:
21512 
        break
21513 
      else:
21514 
        iprot.skip(ftype)
21515 
      iprot.readFieldEnd()
21516 
    iprot.readStructEnd()
21517 
 
21518 
  def write(self, oprot):
21519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21521 
      return
21522 
    oprot.writeStructBegin('addAmazonItem_result')
21523 
    oprot.writeFieldStop()
21524 
    oprot.writeStructEnd()
21525 
 
21526 
  def validate(self):
21527 
    return
21528 
 
21529 
 
21530 
  def __repr__(self):
21531 
    L = ['%s=%r' % (key, value)
21532 
      for key, value in self.__dict__.iteritems()]
21533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21534 
 
21535 
  def __eq__(self, other):
21536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21537 
 
21538 
  def __ne__(self, other):
21539 
    return not (self == other)
7291 vikram.rag 21540 
 
21541 
class getAsinItems_args:
21542 
 
21543 
  thrift_spec = (
21544 
  )
21545 
 
21546 
  def read(self, iprot):
21547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21549 
      return
21550 
    iprot.readStructBegin()
21551 
    while True:
21552 
      (fname, ftype, fid) = iprot.readFieldBegin()
21553 
      if ftype == TType.STOP:
21554 
        break
21555 
      else:
21556 
        iprot.skip(ftype)
21557 
      iprot.readFieldEnd()
21558 
    iprot.readStructEnd()
21559 
 
21560 
  def write(self, oprot):
21561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21563 
      return
21564 
    oprot.writeStructBegin('getAsinItems_args')
21565 
    oprot.writeFieldStop()
21566 
    oprot.writeStructEnd()
21567 
 
21568 
  def validate(self):
21569 
    return
21570 
 
21571 
 
21572 
  def __repr__(self):
21573 
    L = ['%s=%r' % (key, value)
21574 
      for key, value in self.__dict__.iteritems()]
21575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21576 
 
21577 
  def __eq__(self, other):
21578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21579 
 
21580 
  def __ne__(self, other):
21581 
    return not (self == other)
21582 
 
21583 
class getAsinItems_result:
21584 
  """
21585 
  Attributes:
21586 
   - success
21587 
  """
21588 
 
21589 
  thrift_spec = (
21590 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21591 
  )
21592 
 
21593 
  def __init__(self, success=None,):
21594 
    self.success = success
21595 
 
21596 
  def read(self, iprot):
21597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21599 
      return
21600 
    iprot.readStructBegin()
21601 
    while True:
21602 
      (fname, ftype, fid) = iprot.readFieldBegin()
21603 
      if ftype == TType.STOP:
21604 
        break
21605 
      if fid == 0:
21606 
        if ftype == TType.LIST:
21607 
          self.success = []
9155 kshitij.so 21608 
          (_etype442, _size439) = iprot.readListBegin()
21609 
          for _i443 in xrange(_size439):
21610 
            _elem444 = Item()
21611 
            _elem444.read(iprot)
21612 
            self.success.append(_elem444)
7291 vikram.rag 21613 
          iprot.readListEnd()
21614 
        else:
21615 
          iprot.skip(ftype)
21616 
      else:
21617 
        iprot.skip(ftype)
21618 
      iprot.readFieldEnd()
21619 
    iprot.readStructEnd()
21620 
 
21621 
  def write(self, oprot):
21622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21624 
      return
21625 
    oprot.writeStructBegin('getAsinItems_result')
21626 
    if self.success is not None:
21627 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21628 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21629 
      for iter445 in self.success:
21630 
        iter445.write(oprot)
7291 vikram.rag 21631 
      oprot.writeListEnd()
21632 
      oprot.writeFieldEnd()
21633 
    oprot.writeFieldStop()
21634 
    oprot.writeStructEnd()
21635 
 
21636 
  def validate(self):
21637 
    return
21638 
 
21639 
 
21640 
  def __repr__(self):
21641 
    L = ['%s=%r' % (key, value)
21642 
      for key, value in self.__dict__.iteritems()]
21643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21644 
 
21645 
  def __eq__(self, other):
21646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21647 
 
21648 
  def __ne__(self, other):
21649 
    return not (self == other)
21650 
 
21651 
class getAllFbaListedItems_args:
21652 
 
21653 
  thrift_spec = (
21654 
  )
21655 
 
21656 
  def read(self, iprot):
21657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21659 
      return
21660 
    iprot.readStructBegin()
21661 
    while True:
21662 
      (fname, ftype, fid) = iprot.readFieldBegin()
21663 
      if ftype == TType.STOP:
21664 
        break
21665 
      else:
21666 
        iprot.skip(ftype)
21667 
      iprot.readFieldEnd()
21668 
    iprot.readStructEnd()
21669 
 
21670 
  def write(self, oprot):
21671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21673 
      return
21674 
    oprot.writeStructBegin('getAllFbaListedItems_args')
21675 
    oprot.writeFieldStop()
21676 
    oprot.writeStructEnd()
21677 
 
21678 
  def validate(self):
21679 
    return
21680 
 
21681 
 
21682 
  def __repr__(self):
21683 
    L = ['%s=%r' % (key, value)
21684 
      for key, value in self.__dict__.iteritems()]
21685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21686 
 
21687 
  def __eq__(self, other):
21688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21689 
 
21690 
  def __ne__(self, other):
21691 
    return not (self == other)
21692 
 
21693 
class getAllFbaListedItems_result:
21694 
  """
21695 
  Attributes:
21696 
   - success
21697 
  """
21698 
 
21699 
  thrift_spec = (
21700 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21701 
  )
21702 
 
21703 
  def __init__(self, success=None,):
21704 
    self.success = success
21705 
 
21706 
  def read(self, iprot):
21707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21709 
      return
21710 
    iprot.readStructBegin()
21711 
    while True:
21712 
      (fname, ftype, fid) = iprot.readFieldBegin()
21713 
      if ftype == TType.STOP:
21714 
        break
21715 
      if fid == 0:
21716 
        if ftype == TType.LIST:
21717 
          self.success = []
9155 kshitij.so 21718 
          (_etype449, _size446) = iprot.readListBegin()
21719 
          for _i450 in xrange(_size446):
21720 
            _elem451 = Amazonlisted()
21721 
            _elem451.read(iprot)
21722 
            self.success.append(_elem451)
7291 vikram.rag 21723 
          iprot.readListEnd()
21724 
        else:
21725 
          iprot.skip(ftype)
21726 
      else:
21727 
        iprot.skip(ftype)
21728 
      iprot.readFieldEnd()
21729 
    iprot.readStructEnd()
21730 
 
21731 
  def write(self, oprot):
21732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21734 
      return
21735 
    oprot.writeStructBegin('getAllFbaListedItems_result')
21736 
    if self.success is not None:
21737 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21738 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21739 
      for iter452 in self.success:
21740 
        iter452.write(oprot)
7291 vikram.rag 21741 
      oprot.writeListEnd()
21742 
      oprot.writeFieldEnd()
21743 
    oprot.writeFieldStop()
21744 
    oprot.writeStructEnd()
21745 
 
21746 
  def validate(self):
21747 
    return
21748 
 
21749 
 
21750 
  def __repr__(self):
21751 
    L = ['%s=%r' % (key, value)
21752 
      for key, value in self.__dict__.iteritems()]
21753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21754 
 
21755 
  def __eq__(self, other):
21756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21757 
 
21758 
  def __ne__(self, other):
21759 
    return not (self == other)
21760 
 
21761 
class getAllNonFbaListedItems_args:
21762 
 
21763 
  thrift_spec = (
21764 
  )
21765 
 
21766 
  def read(self, iprot):
21767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21769 
      return
21770 
    iprot.readStructBegin()
21771 
    while True:
21772 
      (fname, ftype, fid) = iprot.readFieldBegin()
21773 
      if ftype == TType.STOP:
21774 
        break
21775 
      else:
21776 
        iprot.skip(ftype)
21777 
      iprot.readFieldEnd()
21778 
    iprot.readStructEnd()
21779 
 
21780 
  def write(self, oprot):
21781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21783 
      return
21784 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
21785 
    oprot.writeFieldStop()
21786 
    oprot.writeStructEnd()
21787 
 
21788 
  def validate(self):
21789 
    return
21790 
 
21791 
 
21792 
  def __repr__(self):
21793 
    L = ['%s=%r' % (key, value)
21794 
      for key, value in self.__dict__.iteritems()]
21795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21796 
 
21797 
  def __eq__(self, other):
21798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21799 
 
21800 
  def __ne__(self, other):
21801 
    return not (self == other)
21802 
 
21803 
class getAllNonFbaListedItems_result:
21804 
  """
21805 
  Attributes:
21806 
   - success
21807 
  """
21808 
 
21809 
  thrift_spec = (
21810 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21811 
  )
21812 
 
21813 
  def __init__(self, success=None,):
21814 
    self.success = success
21815 
 
21816 
  def read(self, iprot):
21817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21819 
      return
21820 
    iprot.readStructBegin()
21821 
    while True:
21822 
      (fname, ftype, fid) = iprot.readFieldBegin()
21823 
      if ftype == TType.STOP:
21824 
        break
21825 
      if fid == 0:
21826 
        if ftype == TType.LIST:
21827 
          self.success = []
9155 kshitij.so 21828 
          (_etype456, _size453) = iprot.readListBegin()
21829 
          for _i457 in xrange(_size453):
21830 
            _elem458 = Amazonlisted()
21831 
            _elem458.read(iprot)
21832 
            self.success.append(_elem458)
7291 vikram.rag 21833 
          iprot.readListEnd()
21834 
        else:
21835 
          iprot.skip(ftype)
21836 
      else:
21837 
        iprot.skip(ftype)
21838 
      iprot.readFieldEnd()
21839 
    iprot.readStructEnd()
21840 
 
21841 
  def write(self, oprot):
21842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21844 
      return
21845 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
21846 
    if self.success is not None:
21847 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21848 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21849 
      for iter459 in self.success:
21850 
        iter459.write(oprot)
7291 vikram.rag 21851 
      oprot.writeListEnd()
21852 
      oprot.writeFieldEnd()
21853 
    oprot.writeFieldStop()
21854 
    oprot.writeStructEnd()
21855 
 
21856 
  def validate(self):
21857 
    return
21858 
 
21859 
 
21860 
  def __repr__(self):
21861 
    L = ['%s=%r' % (key, value)
21862 
      for key, value in self.__dict__.iteritems()]
21863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21864 
 
21865 
  def __eq__(self, other):
21866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21867 
 
21868 
  def __ne__(self, other):
21869 
    return not (self == other)
7460 kshitij.so 21870 
 
21871 
class updateItemInventory_args:
21872 
  """
21873 
  Attributes:
21874 
   - itemId
21875 
   - holdInventory
21876 
   - defaultInventory
21877 
  """
21878 
 
21879 
  thrift_spec = (
21880 
    None, # 0
21881 
    (1, TType.I64, 'itemId', None, None, ), # 1
21882 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
21883 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
21884 
  )
21885 
 
21886 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
21887 
    self.itemId = itemId
21888 
    self.holdInventory = holdInventory
21889 
    self.defaultInventory = defaultInventory
21890 
 
21891 
  def read(self, iprot):
21892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21894 
      return
21895 
    iprot.readStructBegin()
21896 
    while True:
21897 
      (fname, ftype, fid) = iprot.readFieldBegin()
21898 
      if ftype == TType.STOP:
21899 
        break
21900 
      if fid == 1:
21901 
        if ftype == TType.I64:
21902 
          self.itemId = iprot.readI64();
21903 
        else:
21904 
          iprot.skip(ftype)
21905 
      elif fid == 2:
21906 
        if ftype == TType.I64:
21907 
          self.holdInventory = iprot.readI64();
21908 
        else:
21909 
          iprot.skip(ftype)
21910 
      elif fid == 3:
21911 
        if ftype == TType.I64:
21912 
          self.defaultInventory = iprot.readI64();
21913 
        else:
21914 
          iprot.skip(ftype)
21915 
      else:
21916 
        iprot.skip(ftype)
21917 
      iprot.readFieldEnd()
21918 
    iprot.readStructEnd()
21919 
 
21920 
  def write(self, oprot):
21921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21923 
      return
21924 
    oprot.writeStructBegin('updateItemInventory_args')
21925 
    if self.itemId is not None:
21926 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21927 
      oprot.writeI64(self.itemId)
21928 
      oprot.writeFieldEnd()
21929 
    if self.holdInventory is not None:
21930 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
21931 
      oprot.writeI64(self.holdInventory)
21932 
      oprot.writeFieldEnd()
21933 
    if self.defaultInventory is not None:
21934 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
21935 
      oprot.writeI64(self.defaultInventory)
21936 
      oprot.writeFieldEnd()
21937 
    oprot.writeFieldStop()
21938 
    oprot.writeStructEnd()
21939 
 
21940 
  def validate(self):
21941 
    return
21942 
 
21943 
 
21944 
  def __repr__(self):
21945 
    L = ['%s=%r' % (key, value)
21946 
      for key, value in self.__dict__.iteritems()]
21947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21948 
 
21949 
  def __eq__(self, other):
21950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21951 
 
21952 
  def __ne__(self, other):
21953 
    return not (self == other)
21954 
 
21955 
class updateItemInventory_result:
21956 
  """
21957 
  Attributes:
21958 
   - success
21959 
  """
21960 
 
21961 
  thrift_spec = (
21962 
    (0, TType.BOOL, 'success', None, None, ), # 0
21963 
  )
21964 
 
21965 
  def __init__(self, success=None,):
21966 
    self.success = success
21967 
 
21968 
  def read(self, iprot):
21969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21971 
      return
21972 
    iprot.readStructBegin()
21973 
    while True:
21974 
      (fname, ftype, fid) = iprot.readFieldBegin()
21975 
      if ftype == TType.STOP:
21976 
        break
21977 
      if fid == 0:
21978 
        if ftype == TType.BOOL:
21979 
          self.success = iprot.readBool();
21980 
        else:
21981 
          iprot.skip(ftype)
21982 
      else:
21983 
        iprot.skip(ftype)
21984 
      iprot.readFieldEnd()
21985 
    iprot.readStructEnd()
21986 
 
21987 
  def write(self, oprot):
21988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21990 
      return
21991 
    oprot.writeStructBegin('updateItemInventory_result')
21992 
    if self.success is not None:
21993 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21994 
      oprot.writeBool(self.success)
21995 
      oprot.writeFieldEnd()
21996 
    oprot.writeFieldStop()
21997 
    oprot.writeStructEnd()
21998 
 
21999 
  def validate(self):
22000 
    return
22001 
 
22002 
 
22003 
  def __repr__(self):
22004 
    L = ['%s=%r' % (key, value)
22005 
      for key, value in self.__dict__.iteritems()]
22006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22007 
 
22008 
  def __eq__(self, other):
22009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22010 
 
22011 
  def __ne__(self, other):
22012 
    return not (self == other)
7770 kshitij.so 22013 
 
22014 
class updateTimestampForAmazonFeeds_args:
22015 
  """
22016 
  Attributes:
22017 
   - type
22018 
   - sku
22019 
   - timestamp
22020 
  """
22021 
 
22022 
  thrift_spec = (
22023 
    None, # 0
22024 
    (1, TType.STRING, 'type', None, None, ), # 1
22025 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
22026 
    (3, TType.I64, 'timestamp', None, None, ), # 3
22027 
  )
22028 
 
22029 
  def __init__(self, type=None, sku=None, timestamp=None,):
22030 
    self.type = type
22031 
    self.sku = sku
22032 
    self.timestamp = timestamp
22033 
 
22034 
  def read(self, iprot):
22035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22037 
      return
22038 
    iprot.readStructBegin()
22039 
    while True:
22040 
      (fname, ftype, fid) = iprot.readFieldBegin()
22041 
      if ftype == TType.STOP:
22042 
        break
22043 
      if fid == 1:
22044 
        if ftype == TType.STRING:
22045 
          self.type = iprot.readString();
22046 
        else:
22047 
          iprot.skip(ftype)
22048 
      elif fid == 2:
22049 
        if ftype == TType.LIST:
22050 
          self.sku = []
9155 kshitij.so 22051 
          (_etype463, _size460) = iprot.readListBegin()
22052 
          for _i464 in xrange(_size460):
22053 
            _elem465 = iprot.readI64();
22054 
            self.sku.append(_elem465)
7770 kshitij.so 22055 
          iprot.readListEnd()
22056 
        else:
22057 
          iprot.skip(ftype)
22058 
      elif fid == 3:
22059 
        if ftype == TType.I64:
22060 
          self.timestamp = iprot.readI64();
22061 
        else:
22062 
          iprot.skip(ftype)
22063 
      else:
22064 
        iprot.skip(ftype)
22065 
      iprot.readFieldEnd()
22066 
    iprot.readStructEnd()
22067 
 
22068 
  def write(self, oprot):
22069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22071 
      return
22072 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
22073 
    if self.type is not None:
22074 
      oprot.writeFieldBegin('type', TType.STRING, 1)
22075 
      oprot.writeString(self.type)
22076 
      oprot.writeFieldEnd()
22077 
    if self.sku is not None:
22078 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
22079 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 22080 
      for iter466 in self.sku:
22081 
        oprot.writeI64(iter466)
7770 kshitij.so 22082 
      oprot.writeListEnd()
22083 
      oprot.writeFieldEnd()
22084 
    if self.timestamp is not None:
22085 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
22086 
      oprot.writeI64(self.timestamp)
22087 
      oprot.writeFieldEnd()
22088 
    oprot.writeFieldStop()
22089 
    oprot.writeStructEnd()
22090 
 
22091 
  def validate(self):
22092 
    return
22093 
 
22094 
 
22095 
  def __repr__(self):
22096 
    L = ['%s=%r' % (key, value)
22097 
      for key, value in self.__dict__.iteritems()]
22098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22099 
 
22100 
  def __eq__(self, other):
22101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22102 
 
22103 
  def __ne__(self, other):
22104 
    return not (self == other)
22105 
 
22106 
class updateTimestampForAmazonFeeds_result:
22107 
  """
22108 
  Attributes:
22109 
   - success
22110 
  """
22111 
 
22112 
  thrift_spec = (
22113 
    (0, TType.BOOL, 'success', None, None, ), # 0
22114 
  )
22115 
 
22116 
  def __init__(self, success=None,):
22117 
    self.success = success
22118 
 
22119 
  def read(self, iprot):
22120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22122 
      return
22123 
    iprot.readStructBegin()
22124 
    while True:
22125 
      (fname, ftype, fid) = iprot.readFieldBegin()
22126 
      if ftype == TType.STOP:
22127 
        break
22128 
      if fid == 0:
22129 
        if ftype == TType.BOOL:
22130 
          self.success = iprot.readBool();
22131 
        else:
22132 
          iprot.skip(ftype)
22133 
      else:
22134 
        iprot.skip(ftype)
22135 
      iprot.readFieldEnd()
22136 
    iprot.readStructEnd()
22137 
 
22138 
  def write(self, oprot):
22139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22141 
      return
22142 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
22143 
    if self.success is not None:
22144 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22145 
      oprot.writeBool(self.success)
22146 
      oprot.writeFieldEnd()
22147 
    oprot.writeFieldStop()
22148 
    oprot.writeStructEnd()
22149 
 
22150 
  def validate(self):
22151 
    return
22152 
 
22153 
 
22154 
  def __repr__(self):
22155 
    L = ['%s=%r' % (key, value)
22156 
      for key, value in self.__dict__.iteritems()]
22157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22158 
 
22159 
  def __eq__(self, other):
22160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22161 
 
22162 
  def __ne__(self, other):
22163 
    return not (self == other)
7897 amar.kumar 22164 
 
22165 
class getAllParentCategories_args:
22166 
 
22167 
  thrift_spec = (
22168 
  )
22169 
 
22170 
  def read(self, iprot):
22171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22173 
      return
22174 
    iprot.readStructBegin()
22175 
    while True:
22176 
      (fname, ftype, fid) = iprot.readFieldBegin()
22177 
      if ftype == TType.STOP:
22178 
        break
22179 
      else:
22180 
        iprot.skip(ftype)
22181 
      iprot.readFieldEnd()
22182 
    iprot.readStructEnd()
22183 
 
22184 
  def write(self, oprot):
22185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22187 
      return
22188 
    oprot.writeStructBegin('getAllParentCategories_args')
22189 
    oprot.writeFieldStop()
22190 
    oprot.writeStructEnd()
22191 
 
22192 
  def validate(self):
22193 
    return
22194 
 
22195 
 
22196 
  def __repr__(self):
22197 
    L = ['%s=%r' % (key, value)
22198 
      for key, value in self.__dict__.iteritems()]
22199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22200 
 
22201 
  def __eq__(self, other):
22202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22203 
 
22204 
  def __ne__(self, other):
22205 
    return not (self == other)
22206 
 
22207 
class getAllParentCategories_result:
22208 
  """
22209 
  Attributes:
22210 
   - success
22211 
  """
22212 
 
22213 
  thrift_spec = (
22214 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
22215 
  )
22216 
 
22217 
  def __init__(self, success=None,):
22218 
    self.success = success
22219 
 
22220 
  def read(self, iprot):
22221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22223 
      return
22224 
    iprot.readStructBegin()
22225 
    while True:
22226 
      (fname, ftype, fid) = iprot.readFieldBegin()
22227 
      if ftype == TType.STOP:
22228 
        break
22229 
      if fid == 0:
22230 
        if ftype == TType.LIST:
22231 
          self.success = []
9155 kshitij.so 22232 
          (_etype470, _size467) = iprot.readListBegin()
22233 
          for _i471 in xrange(_size467):
22234 
            _elem472 = Category()
22235 
            _elem472.read(iprot)
22236 
            self.success.append(_elem472)
7897 amar.kumar 22237 
          iprot.readListEnd()
22238 
        else:
22239 
          iprot.skip(ftype)
22240 
      else:
22241 
        iprot.skip(ftype)
22242 
      iprot.readFieldEnd()
22243 
    iprot.readStructEnd()
22244 
 
22245 
  def write(self, oprot):
22246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22248 
      return
22249 
    oprot.writeStructBegin('getAllParentCategories_result')
22250 
    if self.success is not None:
22251 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22252 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22253 
      for iter473 in self.success:
22254 
        iter473.write(oprot)
7897 amar.kumar 22255 
      oprot.writeListEnd()
22256 
      oprot.writeFieldEnd()
22257 
    oprot.writeFieldStop()
22258 
    oprot.writeStructEnd()
22259 
 
22260 
  def validate(self):
22261 
    return
22262 
 
22263 
 
22264 
  def __repr__(self):
22265 
    L = ['%s=%r' % (key, value)
22266 
      for key, value in self.__dict__.iteritems()]
22267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22268 
 
22269 
  def __eq__(self, other):
22270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22271 
 
22272 
  def __ne__(self, other):
22273 
    return not (self == other)
7977 kshitij.so 22274 
 
22275 
class addPageViewEvent_args:
22276 
  """
22277 
  Attributes:
22278 
   - pageViewEvents
22279 
  """
22280 
 
22281 
  thrift_spec = (
22282 
    None, # 0
22283 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
22284 
  )
22285 
 
22286 
  def __init__(self, pageViewEvents=None,):
22287 
    self.pageViewEvents = pageViewEvents
22288 
 
22289 
  def read(self, iprot):
22290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22292 
      return
22293 
    iprot.readStructBegin()
22294 
    while True:
22295 
      (fname, ftype, fid) = iprot.readFieldBegin()
22296 
      if ftype == TType.STOP:
22297 
        break
22298 
      if fid == 1:
22299 
        if ftype == TType.STRUCT:
22300 
          self.pageViewEvents = PageViewEvents()
22301 
          self.pageViewEvents.read(iprot)
22302 
        else:
22303 
          iprot.skip(ftype)
22304 
      else:
22305 
        iprot.skip(ftype)
22306 
      iprot.readFieldEnd()
22307 
    iprot.readStructEnd()
22308 
 
22309 
  def write(self, oprot):
22310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22312 
      return
22313 
    oprot.writeStructBegin('addPageViewEvent_args')
22314 
    if self.pageViewEvents is not None:
22315 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
22316 
      self.pageViewEvents.write(oprot)
22317 
      oprot.writeFieldEnd()
22318 
    oprot.writeFieldStop()
22319 
    oprot.writeStructEnd()
22320 
 
22321 
  def validate(self):
22322 
    return
22323 
 
22324 
 
22325 
  def __repr__(self):
22326 
    L = ['%s=%r' % (key, value)
22327 
      for key, value in self.__dict__.iteritems()]
22328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22329 
 
22330 
  def __eq__(self, other):
22331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22332 
 
22333 
  def __ne__(self, other):
22334 
    return not (self == other)
22335 
 
22336 
class addPageViewEvent_result:
22337 
 
22338 
  thrift_spec = (
22339 
  )
22340 
 
22341 
  def read(self, iprot):
22342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22344 
      return
22345 
    iprot.readStructBegin()
22346 
    while True:
22347 
      (fname, ftype, fid) = iprot.readFieldBegin()
22348 
      if ftype == TType.STOP:
22349 
        break
22350 
      else:
22351 
        iprot.skip(ftype)
22352 
      iprot.readFieldEnd()
22353 
    iprot.readStructEnd()
22354 
 
22355 
  def write(self, oprot):
22356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22358 
      return
22359 
    oprot.writeStructBegin('addPageViewEvent_result')
22360 
    oprot.writeFieldStop()
22361 
    oprot.writeStructEnd()
22362 
 
22363 
  def validate(self):
22364 
    return
22365 
 
22366 
 
22367 
  def __repr__(self):
22368 
    L = ['%s=%r' % (key, value)
22369 
      for key, value in self.__dict__.iteritems()]
22370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22371 
 
22372 
  def __eq__(self, other):
22373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22374 
 
22375 
  def __ne__(self, other):
22376 
    return not (self == other)
22377 
 
22378 
class addCartEvent_args:
22379 
  """
22380 
  Attributes:
22381 
   - cartEvents
22382 
  """
22383 
 
22384 
  thrift_spec = (
22385 
    None, # 0
22386 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
22387 
  )
22388 
 
22389 
  def __init__(self, cartEvents=None,):
22390 
    self.cartEvents = cartEvents
22391 
 
22392 
  def read(self, iprot):
22393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22395 
      return
22396 
    iprot.readStructBegin()
22397 
    while True:
22398 
      (fname, ftype, fid) = iprot.readFieldBegin()
22399 
      if ftype == TType.STOP:
22400 
        break
22401 
      if fid == 1:
22402 
        if ftype == TType.STRUCT:
22403 
          self.cartEvents = CartEvents()
22404 
          self.cartEvents.read(iprot)
22405 
        else:
22406 
          iprot.skip(ftype)
22407 
      else:
22408 
        iprot.skip(ftype)
22409 
      iprot.readFieldEnd()
22410 
    iprot.readStructEnd()
22411 
 
22412 
  def write(self, oprot):
22413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22415 
      return
22416 
    oprot.writeStructBegin('addCartEvent_args')
22417 
    if self.cartEvents is not None:
22418 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
22419 
      self.cartEvents.write(oprot)
22420 
      oprot.writeFieldEnd()
22421 
    oprot.writeFieldStop()
22422 
    oprot.writeStructEnd()
22423 
 
22424 
  def validate(self):
22425 
    return
22426 
 
22427 
 
22428 
  def __repr__(self):
22429 
    L = ['%s=%r' % (key, value)
22430 
      for key, value in self.__dict__.iteritems()]
22431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22432 
 
22433 
  def __eq__(self, other):
22434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22435 
 
22436 
  def __ne__(self, other):
22437 
    return not (self == other)
22438 
 
22439 
class addCartEvent_result:
22440 
 
22441 
  thrift_spec = (
22442 
  )
22443 
 
22444 
  def read(self, iprot):
22445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22447 
      return
22448 
    iprot.readStructBegin()
22449 
    while True:
22450 
      (fname, ftype, fid) = iprot.readFieldBegin()
22451 
      if ftype == TType.STOP:
22452 
        break
22453 
      else:
22454 
        iprot.skip(ftype)
22455 
      iprot.readFieldEnd()
22456 
    iprot.readStructEnd()
22457 
 
22458 
  def write(self, oprot):
22459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22461 
      return
22462 
    oprot.writeStructBegin('addCartEvent_result')
22463 
    oprot.writeFieldStop()
22464 
    oprot.writeStructEnd()
22465 
 
22466 
  def validate(self):
22467 
    return
22468 
 
22469 
 
22470 
  def __repr__(self):
22471 
    L = ['%s=%r' % (key, value)
22472 
      for key, value in self.__dict__.iteritems()]
22473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22474 
 
22475 
  def __eq__(self, other):
22476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22477 
 
22478 
  def __ne__(self, other):
22479 
    return not (self == other)
8139 kshitij.so 22480 
 
8182 amar.kumar 22481 
class addEbayItem_args:
22482 
  """
22483 
  Attributes:
22484 
   - ebayItem
22485 
  """
22486 
 
22487 
  thrift_spec = (
22488 
    None, # 0
22489 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22490 
  )
22491 
 
22492 
  def __init__(self, ebayItem=None,):
22493 
    self.ebayItem = ebayItem
22494 
 
22495 
  def read(self, iprot):
22496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22498 
      return
22499 
    iprot.readStructBegin()
22500 
    while True:
22501 
      (fname, ftype, fid) = iprot.readFieldBegin()
22502 
      if ftype == TType.STOP:
22503 
        break
22504 
      if fid == 1:
22505 
        if ftype == TType.STRUCT:
22506 
          self.ebayItem = EbayItem()
22507 
          self.ebayItem.read(iprot)
22508 
        else:
22509 
          iprot.skip(ftype)
22510 
      else:
22511 
        iprot.skip(ftype)
22512 
      iprot.readFieldEnd()
22513 
    iprot.readStructEnd()
22514 
 
22515 
  def write(self, oprot):
22516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22518 
      return
22519 
    oprot.writeStructBegin('addEbayItem_args')
22520 
    if self.ebayItem is not None:
22521 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22522 
      self.ebayItem.write(oprot)
22523 
      oprot.writeFieldEnd()
22524 
    oprot.writeFieldStop()
22525 
    oprot.writeStructEnd()
22526 
 
22527 
  def validate(self):
22528 
    return
22529 
 
22530 
 
22531 
  def __repr__(self):
22532 
    L = ['%s=%r' % (key, value)
22533 
      for key, value in self.__dict__.iteritems()]
22534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22535 
 
22536 
  def __eq__(self, other):
22537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22538 
 
22539 
  def __ne__(self, other):
22540 
    return not (self == other)
22541 
 
22542 
class addEbayItem_result:
22543 
 
22544 
  thrift_spec = (
22545 
  )
22546 
 
22547 
  def read(self, iprot):
22548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22550 
      return
22551 
    iprot.readStructBegin()
22552 
    while True:
22553 
      (fname, ftype, fid) = iprot.readFieldBegin()
22554 
      if ftype == TType.STOP:
22555 
        break
22556 
      else:
22557 
        iprot.skip(ftype)
22558 
      iprot.readFieldEnd()
22559 
    iprot.readStructEnd()
22560 
 
22561 
  def write(self, oprot):
22562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22564 
      return
22565 
    oprot.writeStructBegin('addEbayItem_result')
22566 
    oprot.writeFieldStop()
22567 
    oprot.writeStructEnd()
22568 
 
22569 
  def validate(self):
22570 
    return
22571 
 
22572 
 
22573 
  def __repr__(self):
22574 
    L = ['%s=%r' % (key, value)
22575 
      for key, value in self.__dict__.iteritems()]
22576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22577 
 
22578 
  def __eq__(self, other):
22579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22580 
 
22581 
  def __ne__(self, other):
22582 
    return not (self == other)
22583 
 
22584 
class getEbayItem_args:
22585 
  """
22586 
  Attributes:
22587 
   - listingId
22588 
  """
22589 
 
22590 
  thrift_spec = (
22591 
    None, # 0
22592 
    (1, TType.STRING, 'listingId', None, None, ), # 1
22593 
  )
22594 
 
22595 
  def __init__(self, listingId=None,):
22596 
    self.listingId = listingId
22597 
 
22598 
  def read(self, iprot):
22599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22601 
      return
22602 
    iprot.readStructBegin()
22603 
    while True:
22604 
      (fname, ftype, fid) = iprot.readFieldBegin()
22605 
      if ftype == TType.STOP:
22606 
        break
22607 
      if fid == 1:
22608 
        if ftype == TType.STRING:
22609 
          self.listingId = iprot.readString();
22610 
        else:
22611 
          iprot.skip(ftype)
22612 
      else:
22613 
        iprot.skip(ftype)
22614 
      iprot.readFieldEnd()
22615 
    iprot.readStructEnd()
22616 
 
22617 
  def write(self, oprot):
22618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22620 
      return
22621 
    oprot.writeStructBegin('getEbayItem_args')
22622 
    if self.listingId is not None:
22623 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
22624 
      oprot.writeString(self.listingId)
22625 
      oprot.writeFieldEnd()
22626 
    oprot.writeFieldStop()
22627 
    oprot.writeStructEnd()
22628 
 
22629 
  def validate(self):
22630 
    return
22631 
 
22632 
 
22633 
  def __repr__(self):
22634 
    L = ['%s=%r' % (key, value)
22635 
      for key, value in self.__dict__.iteritems()]
22636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22637 
 
22638 
  def __eq__(self, other):
22639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22640 
 
22641 
  def __ne__(self, other):
22642 
    return not (self == other)
22643 
 
22644 
class getEbayItem_result:
22645 
  """
22646 
  Attributes:
22647 
   - success
22648 
  """
22649 
 
22650 
  thrift_spec = (
22651 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
22652 
  )
22653 
 
22654 
  def __init__(self, success=None,):
22655 
    self.success = success
22656 
 
22657 
  def read(self, iprot):
22658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22660 
      return
22661 
    iprot.readStructBegin()
22662 
    while True:
22663 
      (fname, ftype, fid) = iprot.readFieldBegin()
22664 
      if ftype == TType.STOP:
22665 
        break
22666 
      if fid == 0:
22667 
        if ftype == TType.STRUCT:
22668 
          self.success = EbayItem()
22669 
          self.success.read(iprot)
22670 
        else:
22671 
          iprot.skip(ftype)
22672 
      else:
22673 
        iprot.skip(ftype)
22674 
      iprot.readFieldEnd()
22675 
    iprot.readStructEnd()
22676 
 
22677 
  def write(self, oprot):
22678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22680 
      return
22681 
    oprot.writeStructBegin('getEbayItem_result')
22682 
    if self.success is not None:
22683 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22684 
      self.success.write(oprot)
22685 
      oprot.writeFieldEnd()
22686 
    oprot.writeFieldStop()
22687 
    oprot.writeStructEnd()
22688 
 
22689 
  def validate(self):
22690 
    return
22691 
 
22692 
 
22693 
  def __repr__(self):
22694 
    L = ['%s=%r' % (key, value)
22695 
      for key, value in self.__dict__.iteritems()]
22696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22697 
 
22698 
  def __eq__(self, other):
22699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22700 
 
22701 
  def __ne__(self, other):
22702 
    return not (self == other)
22703 
 
22704 
class updateEbayItem_args:
22705 
  """
22706 
  Attributes:
22707 
   - ebayItem
22708 
  """
22709 
 
22710 
  thrift_spec = (
22711 
    None, # 0
22712 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22713 
  )
22714 
 
22715 
  def __init__(self, ebayItem=None,):
22716 
    self.ebayItem = ebayItem
22717 
 
22718 
  def read(self, iprot):
22719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22721 
      return
22722 
    iprot.readStructBegin()
22723 
    while True:
22724 
      (fname, ftype, fid) = iprot.readFieldBegin()
22725 
      if ftype == TType.STOP:
22726 
        break
22727 
      if fid == 1:
22728 
        if ftype == TType.STRUCT:
22729 
          self.ebayItem = EbayItem()
22730 
          self.ebayItem.read(iprot)
22731 
        else:
22732 
          iprot.skip(ftype)
22733 
      else:
22734 
        iprot.skip(ftype)
22735 
      iprot.readFieldEnd()
22736 
    iprot.readStructEnd()
22737 
 
22738 
  def write(self, oprot):
22739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22741 
      return
22742 
    oprot.writeStructBegin('updateEbayItem_args')
22743 
    if self.ebayItem is not None:
22744 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22745 
      self.ebayItem.write(oprot)
22746 
      oprot.writeFieldEnd()
22747 
    oprot.writeFieldStop()
22748 
    oprot.writeStructEnd()
22749 
 
22750 
  def validate(self):
22751 
    return
22752 
 
22753 
 
22754 
  def __repr__(self):
22755 
    L = ['%s=%r' % (key, value)
22756 
      for key, value in self.__dict__.iteritems()]
22757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22758 
 
22759 
  def __eq__(self, other):
22760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22761 
 
22762 
  def __ne__(self, other):
22763 
    return not (self == other)
22764 
 
22765 
class updateEbayItem_result:
22766 
 
22767 
  thrift_spec = (
22768 
  )
22769 
 
22770 
  def read(self, iprot):
22771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22773 
      return
22774 
    iprot.readStructBegin()
22775 
    while True:
22776 
      (fname, ftype, fid) = iprot.readFieldBegin()
22777 
      if ftype == TType.STOP:
22778 
        break
22779 
      else:
22780 
        iprot.skip(ftype)
22781 
      iprot.readFieldEnd()
22782 
    iprot.readStructEnd()
22783 
 
22784 
  def write(self, oprot):
22785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22787 
      return
22788 
    oprot.writeStructBegin('updateEbayItem_result')
22789 
    oprot.writeFieldStop()
22790 
    oprot.writeStructEnd()
22791 
 
22792 
  def validate(self):
22793 
    return
22794 
 
22795 
 
22796 
  def __repr__(self):
22797 
    L = ['%s=%r' % (key, value)
22798 
      for key, value in self.__dict__.iteritems()]
22799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22800 
 
22801 
  def __eq__(self, other):
22802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22803 
 
22804 
  def __ne__(self, other):
22805 
    return not (self == other)
22806 
 
8139 kshitij.so 22807 
class getAmazonListedItems_args:
22808 
  """
22809 
  Attributes:
22810 
   - offset
22811 
   - limit
22812 
  """
22813 
 
22814 
  thrift_spec = (
22815 
    None, # 0
22816 
    (1, TType.I64, 'offset', None, None, ), # 1
22817 
    (2, TType.I64, 'limit', None, None, ), # 2
22818 
  )
22819 
 
22820 
  def __init__(self, offset=None, limit=None,):
22821 
    self.offset = offset
22822 
    self.limit = limit
22823 
 
22824 
  def read(self, iprot):
22825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22827 
      return
22828 
    iprot.readStructBegin()
22829 
    while True:
22830 
      (fname, ftype, fid) = iprot.readFieldBegin()
22831 
      if ftype == TType.STOP:
22832 
        break
22833 
      if fid == 1:
22834 
        if ftype == TType.I64:
22835 
          self.offset = iprot.readI64();
22836 
        else:
22837 
          iprot.skip(ftype)
22838 
      elif fid == 2:
22839 
        if ftype == TType.I64:
22840 
          self.limit = iprot.readI64();
22841 
        else:
22842 
          iprot.skip(ftype)
22843 
      else:
22844 
        iprot.skip(ftype)
22845 
      iprot.readFieldEnd()
22846 
    iprot.readStructEnd()
22847 
 
22848 
  def write(self, oprot):
22849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22851 
      return
22852 
    oprot.writeStructBegin('getAmazonListedItems_args')
22853 
    if self.offset is not None:
22854 
      oprot.writeFieldBegin('offset', TType.I64, 1)
22855 
      oprot.writeI64(self.offset)
22856 
      oprot.writeFieldEnd()
22857 
    if self.limit is not None:
22858 
      oprot.writeFieldBegin('limit', TType.I64, 2)
22859 
      oprot.writeI64(self.limit)
22860 
      oprot.writeFieldEnd()
22861 
    oprot.writeFieldStop()
22862 
    oprot.writeStructEnd()
22863 
 
22864 
  def validate(self):
22865 
    return
22866 
 
22867 
 
22868 
  def __repr__(self):
22869 
    L = ['%s=%r' % (key, value)
22870 
      for key, value in self.__dict__.iteritems()]
22871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22872 
 
22873 
  def __eq__(self, other):
22874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22875 
 
22876 
  def __ne__(self, other):
22877 
    return not (self == other)
22878 
 
22879 
class getAmazonListedItems_result:
22880 
  """
22881 
  Attributes:
22882 
   - success
22883 
  """
22884 
 
22885 
  thrift_spec = (
22886 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22887 
  )
22888 
 
22889 
  def __init__(self, success=None,):
22890 
    self.success = success
22891 
 
22892 
  def read(self, iprot):
22893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22895 
      return
22896 
    iprot.readStructBegin()
22897 
    while True:
22898 
      (fname, ftype, fid) = iprot.readFieldBegin()
22899 
      if ftype == TType.STOP:
22900 
        break
22901 
      if fid == 0:
22902 
        if ftype == TType.LIST:
22903 
          self.success = []
9155 kshitij.so 22904 
          (_etype477, _size474) = iprot.readListBegin()
22905 
          for _i478 in xrange(_size474):
22906 
            _elem479 = Amazonlisted()
22907 
            _elem479.read(iprot)
22908 
            self.success.append(_elem479)
8139 kshitij.so 22909 
          iprot.readListEnd()
22910 
        else:
22911 
          iprot.skip(ftype)
22912 
      else:
22913 
        iprot.skip(ftype)
22914 
      iprot.readFieldEnd()
22915 
    iprot.readStructEnd()
22916 
 
22917 
  def write(self, oprot):
22918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22920 
      return
22921 
    oprot.writeStructBegin('getAmazonListedItems_result')
22922 
    if self.success is not None:
22923 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22924 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22925 
      for iter480 in self.success:
22926 
        iter480.write(oprot)
8139 kshitij.so 22927 
      oprot.writeListEnd()
22928 
      oprot.writeFieldEnd()
22929 
    oprot.writeFieldStop()
22930 
    oprot.writeStructEnd()
22931 
 
22932 
  def validate(self):
22933 
    return
22934 
 
22935 
 
22936 
  def __repr__(self):
22937 
    L = ['%s=%r' % (key, value)
22938 
      for key, value in self.__dict__.iteritems()]
22939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22940 
 
22941 
  def __eq__(self, other):
22942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22943 
 
22944 
  def __ne__(self, other):
22945 
    return not (self == other)
8168 kshitij.so 22946 
 
22947 
class updateAmazonAttributesInBulk_args:
22948 
  """
22949 
  Attributes:
22950 
   - amazonlisted
22951 
  """
22952 
 
22953 
  thrift_spec = (
22954 
    None, # 0
22955 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
22956 
  )
22957 
 
22958 
  def __init__(self, amazonlisted=None,):
22959 
    self.amazonlisted = amazonlisted
22960 
 
22961 
  def read(self, iprot):
22962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22964 
      return
22965 
    iprot.readStructBegin()
22966 
    while True:
22967 
      (fname, ftype, fid) = iprot.readFieldBegin()
22968 
      if ftype == TType.STOP:
22969 
        break
22970 
      if fid == 1:
22971 
        if ftype == TType.MAP:
22972 
          self.amazonlisted = {}
9155 kshitij.so 22973 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
22974 
          for _i485 in xrange(_size481):
22975 
            _key486 = iprot.readI64();
22976 
            _val487 = Amazonlisted()
22977 
            _val487.read(iprot)
22978 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 22979 
          iprot.readMapEnd()
22980 
        else:
22981 
          iprot.skip(ftype)
22982 
      else:
22983 
        iprot.skip(ftype)
22984 
      iprot.readFieldEnd()
22985 
    iprot.readStructEnd()
22986 
 
22987 
  def write(self, oprot):
22988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22990 
      return
22991 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
22992 
    if self.amazonlisted is not None:
22993 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
22994 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 22995 
      for kiter488,viter489 in self.amazonlisted.items():
22996 
        oprot.writeI64(kiter488)
22997 
        viter489.write(oprot)
8168 kshitij.so 22998 
      oprot.writeMapEnd()
22999 
      oprot.writeFieldEnd()
23000 
    oprot.writeFieldStop()
23001 
    oprot.writeStructEnd()
23002 
 
23003 
  def validate(self):
23004 
    return
23005 
 
23006 
 
23007 
  def __repr__(self):
23008 
    L = ['%s=%r' % (key, value)
23009 
      for key, value in self.__dict__.iteritems()]
23010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23011 
 
23012 
  def __eq__(self, other):
23013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23014 
 
23015 
  def __ne__(self, other):
23016 
    return not (self == other)
23017 
 
23018 
class updateAmazonAttributesInBulk_result:
23019 
  """
23020 
  Attributes:
23021 
   - success
23022 
  """
23023 
 
23024 
  thrift_spec = (
23025 
    (0, TType.BOOL, 'success', None, None, ), # 0
23026 
  )
23027 
 
23028 
  def __init__(self, success=None,):
23029 
    self.success = success
23030 
 
23031 
  def read(self, iprot):
23032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23034 
      return
23035 
    iprot.readStructBegin()
23036 
    while True:
23037 
      (fname, ftype, fid) = iprot.readFieldBegin()
23038 
      if ftype == TType.STOP:
23039 
        break
23040 
      if fid == 0:
23041 
        if ftype == TType.BOOL:
23042 
          self.success = iprot.readBool();
23043 
        else:
23044 
          iprot.skip(ftype)
23045 
      else:
23046 
        iprot.skip(ftype)
23047 
      iprot.readFieldEnd()
23048 
    iprot.readStructEnd()
23049 
 
23050 
  def write(self, oprot):
23051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23053 
      return
23054 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
23055 
    if self.success is not None:
23056 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23057 
      oprot.writeBool(self.success)
23058 
      oprot.writeFieldEnd()
23059 
    oprot.writeFieldStop()
23060 
    oprot.writeStructEnd()
23061 
 
23062 
  def validate(self):
23063 
    return
23064 
 
23065 
 
23066 
  def __repr__(self):
23067 
    L = ['%s=%r' % (key, value)
23068 
      for key, value in self.__dict__.iteritems()]
23069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23070 
 
23071 
  def __eq__(self, other):
23072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23073 
 
23074 
  def __ne__(self, other):
23075 
    return not (self == other)
8379 vikram.rag 23076 
 
23077 
class getAllItemstoListOnFba_args:
23078 
 
23079 
  thrift_spec = (
23080 
  )
23081 
 
23082 
  def read(self, iprot):
23083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23085 
      return
23086 
    iprot.readStructBegin()
23087 
    while True:
23088 
      (fname, ftype, fid) = iprot.readFieldBegin()
23089 
      if ftype == TType.STOP:
23090 
        break
23091 
      else:
23092 
        iprot.skip(ftype)
23093 
      iprot.readFieldEnd()
23094 
    iprot.readStructEnd()
23095 
 
23096 
  def write(self, oprot):
23097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23099 
      return
23100 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
23101 
    oprot.writeFieldStop()
23102 
    oprot.writeStructEnd()
23103 
 
23104 
  def validate(self):
23105 
    return
23106 
 
23107 
 
23108 
  def __repr__(self):
23109 
    L = ['%s=%r' % (key, value)
23110 
      for key, value in self.__dict__.iteritems()]
23111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23112 
 
23113 
  def __eq__(self, other):
23114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23115 
 
23116 
  def __ne__(self, other):
23117 
    return not (self == other)
23118 
 
23119 
class getAllItemstoListOnFba_result:
23120 
  """
23121 
  Attributes:
23122 
   - success
23123 
  """
23124 
 
23125 
  thrift_spec = (
23126 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23127 
  )
23128 
 
23129 
  def __init__(self, success=None,):
23130 
    self.success = success
23131 
 
23132 
  def read(self, iprot):
23133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23135 
      return
23136 
    iprot.readStructBegin()
23137 
    while True:
23138 
      (fname, ftype, fid) = iprot.readFieldBegin()
23139 
      if ftype == TType.STOP:
23140 
        break
23141 
      if fid == 0:
23142 
        if ftype == TType.LIST:
23143 
          self.success = []
9155 kshitij.so 23144 
          (_etype493, _size490) = iprot.readListBegin()
23145 
          for _i494 in xrange(_size490):
23146 
            _elem495 = Amazonlisted()
23147 
            _elem495.read(iprot)
23148 
            self.success.append(_elem495)
8379 vikram.rag 23149 
          iprot.readListEnd()
23150 
        else:
23151 
          iprot.skip(ftype)
23152 
      else:
23153 
        iprot.skip(ftype)
23154 
      iprot.readFieldEnd()
23155 
    iprot.readStructEnd()
23156 
 
23157 
  def write(self, oprot):
23158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23160 
      return
23161 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
23162 
    if self.success is not None:
23163 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23164 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23165 
      for iter496 in self.success:
23166 
        iter496.write(oprot)
8379 vikram.rag 23167 
      oprot.writeListEnd()
23168 
      oprot.writeFieldEnd()
23169 
    oprot.writeFieldStop()
23170 
    oprot.writeStructEnd()
23171 
 
23172 
  def validate(self):
23173 
    return
23174 
 
23175 
 
23176 
  def __repr__(self):
23177 
    L = ['%s=%r' % (key, value)
23178 
      for key, value in self.__dict__.iteritems()]
23179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23180 
 
23181 
  def __eq__(self, other):
23182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23183 
 
23184 
  def __ne__(self, other):
23185 
    return not (self == other)
23186 
 
23187 
class getAllItemstoListOnNonFba_args:
23188 
 
23189 
  thrift_spec = (
23190 
  )
23191 
 
23192 
  def read(self, iprot):
23193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23195 
      return
23196 
    iprot.readStructBegin()
23197 
    while True:
23198 
      (fname, ftype, fid) = iprot.readFieldBegin()
23199 
      if ftype == TType.STOP:
23200 
        break
23201 
      else:
23202 
        iprot.skip(ftype)
23203 
      iprot.readFieldEnd()
23204 
    iprot.readStructEnd()
23205 
 
23206 
  def write(self, oprot):
23207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23209 
      return
23210 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
23211 
    oprot.writeFieldStop()
23212 
    oprot.writeStructEnd()
23213 
 
23214 
  def validate(self):
23215 
    return
23216 
 
23217 
 
23218 
  def __repr__(self):
23219 
    L = ['%s=%r' % (key, value)
23220 
      for key, value in self.__dict__.iteritems()]
23221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23222 
 
23223 
  def __eq__(self, other):
23224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23225 
 
23226 
  def __ne__(self, other):
23227 
    return not (self == other)
23228 
 
23229 
class getAllItemstoListOnNonFba_result:
23230 
  """
23231 
  Attributes:
23232 
   - success
23233 
  """
23234 
 
23235 
  thrift_spec = (
23236 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23237 
  )
23238 
 
23239 
  def __init__(self, success=None,):
23240 
    self.success = success
23241 
 
23242 
  def read(self, iprot):
23243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23245 
      return
23246 
    iprot.readStructBegin()
23247 
    while True:
23248 
      (fname, ftype, fid) = iprot.readFieldBegin()
23249 
      if ftype == TType.STOP:
23250 
        break
23251 
      if fid == 0:
23252 
        if ftype == TType.LIST:
23253 
          self.success = []
9155 kshitij.so 23254 
          (_etype500, _size497) = iprot.readListBegin()
23255 
          for _i501 in xrange(_size497):
23256 
            _elem502 = Amazonlisted()
23257 
            _elem502.read(iprot)
23258 
            self.success.append(_elem502)
8379 vikram.rag 23259 
          iprot.readListEnd()
23260 
        else:
23261 
          iprot.skip(ftype)
23262 
      else:
23263 
        iprot.skip(ftype)
23264 
      iprot.readFieldEnd()
23265 
    iprot.readStructEnd()
23266 
 
23267 
  def write(self, oprot):
23268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23270 
      return
23271 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
23272 
    if self.success is not None:
23273 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23274 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23275 
      for iter503 in self.success:
23276 
        iter503.write(oprot)
8379 vikram.rag 23277 
      oprot.writeListEnd()
23278 
      oprot.writeFieldEnd()
23279 
    oprot.writeFieldStop()
23280 
    oprot.writeStructEnd()
23281 
 
23282 
  def validate(self):
23283 
    return
23284 
 
23285 
 
23286 
  def __repr__(self):
23287 
    L = ['%s=%r' % (key, value)
23288 
      for key, value in self.__dict__.iteritems()]
23289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23290 
 
23291 
  def __eq__(self, other):
23292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23293 
 
23294 
  def __ne__(self, other):
23295 
    return not (self == other)
8616 vikram.rag 23296 
 
9242 kshitij.so 23297 
class updateAsin_args:
23298 
  """
23299 
  Attributes:
23300 
   - item
23301 
  """
8616 vikram.rag 23302 
 
23303 
  thrift_spec = (
9242 kshitij.so 23304 
    None, # 0
23305 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 23306 
  )
23307 
 
9242 kshitij.so 23308 
  def __init__(self, item=None,):
23309 
    self.item = item
23310 
 
8616 vikram.rag 23311 
  def read(self, iprot):
23312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23314 
      return
23315 
    iprot.readStructBegin()
23316 
    while True:
23317 
      (fname, ftype, fid) = iprot.readFieldBegin()
23318 
      if ftype == TType.STOP:
23319 
        break
9242 kshitij.so 23320 
      if fid == 1:
23321 
        if ftype == TType.MAP:
23322 
          self.item = {}
23323 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
23324 
          for _i508 in xrange(_size504):
23325 
            _key509 = iprot.readI64();
23326 
            _val510 = Item()
23327 
            _val510.read(iprot)
23328 
            self.item[_key509] = _val510
23329 
          iprot.readMapEnd()
23330 
        else:
23331 
          iprot.skip(ftype)
8616 vikram.rag 23332 
      else:
23333 
        iprot.skip(ftype)
23334 
      iprot.readFieldEnd()
23335 
    iprot.readStructEnd()
23336 
 
23337 
  def write(self, oprot):
23338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23340 
      return
9242 kshitij.so 23341 
    oprot.writeStructBegin('updateAsin_args')
23342 
    if self.item is not None:
23343 
      oprot.writeFieldBegin('item', TType.MAP, 1)
23344 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
23345 
      for kiter511,viter512 in self.item.items():
23346 
        oprot.writeI64(kiter511)
23347 
        viter512.write(oprot)
23348 
      oprot.writeMapEnd()
23349 
      oprot.writeFieldEnd()
8616 vikram.rag 23350 
    oprot.writeFieldStop()
23351 
    oprot.writeStructEnd()
23352 
 
23353 
  def validate(self):
23354 
    return
23355 
 
23356 
 
23357 
  def __repr__(self):
23358 
    L = ['%s=%r' % (key, value)
23359 
      for key, value in self.__dict__.iteritems()]
23360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23361 
 
23362 
  def __eq__(self, other):
23363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23364 
 
23365 
  def __ne__(self, other):
23366 
    return not (self == other)
23367 
 
9242 kshitij.so 23368 
class updateAsin_result:
8616 vikram.rag 23369 
 
23370 
  thrift_spec = (
23371 
  )
23372 
 
23373 
  def read(self, iprot):
23374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23376 
      return
23377 
    iprot.readStructBegin()
23378 
    while True:
23379 
      (fname, ftype, fid) = iprot.readFieldBegin()
23380 
      if ftype == TType.STOP:
23381 
        break
23382 
      else:
23383 
        iprot.skip(ftype)
23384 
      iprot.readFieldEnd()
23385 
    iprot.readStructEnd()
23386 
 
23387 
  def write(self, oprot):
23388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23390 
      return
9242 kshitij.so 23391 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 23392 
    oprot.writeFieldStop()
23393 
    oprot.writeStructEnd()
23394 
 
23395 
  def validate(self):
23396 
    return
23397 
 
23398 
 
23399 
  def __repr__(self):
23400 
    L = ['%s=%r' % (key, value)
23401 
      for key, value in self.__dict__.iteritems()]
23402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23403 
 
23404 
  def __eq__(self, other):
23405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23406 
 
23407 
  def __ne__(self, other):
23408 
    return not (self == other)
8619 kshitij.so 23409 
 
9242 kshitij.so 23410 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 23411 
  """
23412 
  Attributes:
9242 kshitij.so 23413 
   - snapdealitem
8619 kshitij.so 23414 
  """
23415 
 
9242 kshitij.so 23416 
  thrift_spec = None
23417 
  def __init__(self, snapdealitem=None,):
23418 
    self.snapdealitem = snapdealitem
8619 kshitij.so 23419 
 
23420 
  def read(self, iprot):
23421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23423 
      return
23424 
    iprot.readStructBegin()
23425 
    while True:
23426 
      (fname, ftype, fid) = iprot.readFieldBegin()
23427 
      if ftype == TType.STOP:
23428 
        break
9242 kshitij.so 23429 
      if fid == -1:
23430 
        if ftype == TType.STRUCT:
23431 
          self.snapdealitem = SnapdealItem()
23432 
          self.snapdealitem.read(iprot)
8619 kshitij.so 23433 
        else:
23434 
          iprot.skip(ftype)
23435 
      else:
23436 
        iprot.skip(ftype)
23437 
      iprot.readFieldEnd()
23438 
    iprot.readStructEnd()
23439 
 
23440 
  def write(self, oprot):
23441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23443 
      return
9242 kshitij.so 23444 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
23445 
    if self.snapdealitem is not None:
23446 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
23447 
      self.snapdealitem.write(oprot)
8619 kshitij.so 23448 
      oprot.writeFieldEnd()
23449 
    oprot.writeFieldStop()
23450 
    oprot.writeStructEnd()
23451 
 
23452 
  def validate(self):
23453 
    return
23454 
 
23455 
 
23456 
  def __repr__(self):
23457 
    L = ['%s=%r' % (key, value)
23458 
      for key, value in self.__dict__.iteritems()]
23459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23460 
 
23461 
  def __eq__(self, other):
23462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23463 
 
23464 
  def __ne__(self, other):
23465 
    return not (self == other)
23466 
 
9242 kshitij.so 23467 
class addOrUpdateSnapdealItem_result:
23468 
  """
23469 
  Attributes:
23470 
   - success
23471 
  """
8619 kshitij.so 23472 
 
23473 
  thrift_spec = (
9242 kshitij.so 23474 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 23475 
  )
23476 
 
9242 kshitij.so 23477 
  def __init__(self, success=None,):
23478 
    self.success = success
23479 
 
8619 kshitij.so 23480 
  def read(self, iprot):
23481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23483 
      return
23484 
    iprot.readStructBegin()
23485 
    while True:
23486 
      (fname, ftype, fid) = iprot.readFieldBegin()
23487 
      if ftype == TType.STOP:
23488 
        break
9242 kshitij.so 23489 
      if fid == 0:
23490 
        if ftype == TType.BOOL:
23491 
          self.success = iprot.readBool();
23492 
        else:
23493 
          iprot.skip(ftype)
8619 kshitij.so 23494 
      else:
23495 
        iprot.skip(ftype)
23496 
      iprot.readFieldEnd()
23497 
    iprot.readStructEnd()
23498 
 
23499 
  def write(self, oprot):
23500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23502 
      return
9242 kshitij.so 23503 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
23504 
    if self.success is not None:
23505 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23506 
      oprot.writeBool(self.success)
23507 
      oprot.writeFieldEnd()
8619 kshitij.so 23508 
    oprot.writeFieldStop()
23509 
    oprot.writeStructEnd()
23510 
 
23511 
  def validate(self):
23512 
    return
23513 
 
23514 
 
23515 
  def __repr__(self):
23516 
    L = ['%s=%r' % (key, value)
23517 
      for key, value in self.__dict__.iteritems()]
23518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23519 
 
23520 
  def __eq__(self, other):
23521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23522 
 
23523 
  def __ne__(self, other):
23524 
    return not (self == other)
8739 vikram.rag 23525 
 
9242 kshitij.so 23526 
class getSnapdealItem_args:
8739 vikram.rag 23527 
  """
23528 
  Attributes:
9242 kshitij.so 23529 
   - item_id
8739 vikram.rag 23530 
  """
23531 
 
9242 kshitij.so 23532 
  thrift_spec = (
23533 
    None, # 0
23534 
    (1, TType.I64, 'item_id', None, None, ), # 1
23535 
  )
8739 vikram.rag 23536 
 
9242 kshitij.so 23537 
  def __init__(self, item_id=None,):
23538 
    self.item_id = item_id
23539 
 
8739 vikram.rag 23540 
  def read(self, iprot):
23541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23543 
      return
23544 
    iprot.readStructBegin()
23545 
    while True:
23546 
      (fname, ftype, fid) = iprot.readFieldBegin()
23547 
      if ftype == TType.STOP:
23548 
        break
9242 kshitij.so 23549 
      if fid == 1:
23550 
        if ftype == TType.I64:
23551 
          self.item_id = iprot.readI64();
8739 vikram.rag 23552 
        else:
23553 
          iprot.skip(ftype)
23554 
      else:
23555 
        iprot.skip(ftype)
23556 
      iprot.readFieldEnd()
23557 
    iprot.readStructEnd()
23558 
 
23559 
  def write(self, oprot):
23560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23562 
      return
9242 kshitij.so 23563 
    oprot.writeStructBegin('getSnapdealItem_args')
23564 
    if self.item_id is not None:
23565 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23566 
      oprot.writeI64(self.item_id)
8739 vikram.rag 23567 
      oprot.writeFieldEnd()
23568 
    oprot.writeFieldStop()
23569 
    oprot.writeStructEnd()
23570 
 
23571 
  def validate(self):
23572 
    return
23573 
 
23574 
 
23575 
  def __repr__(self):
23576 
    L = ['%s=%r' % (key, value)
23577 
      for key, value in self.__dict__.iteritems()]
23578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23579 
 
23580 
  def __eq__(self, other):
23581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23582 
 
23583 
  def __ne__(self, other):
23584 
    return not (self == other)
23585 
 
9242 kshitij.so 23586 
class getSnapdealItem_result:
8739 vikram.rag 23587 
  """
23588 
  Attributes:
23589 
   - success
23590 
  """
23591 
 
23592 
  thrift_spec = (
9242 kshitij.so 23593 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 23594 
  )
23595 
 
23596 
  def __init__(self, success=None,):
23597 
    self.success = success
23598 
 
23599 
  def read(self, iprot):
23600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23602 
      return
23603 
    iprot.readStructBegin()
23604 
    while True:
23605 
      (fname, ftype, fid) = iprot.readFieldBegin()
23606 
      if ftype == TType.STOP:
23607 
        break
23608 
      if fid == 0:
9242 kshitij.so 23609 
        if ftype == TType.STRUCT:
23610 
          self.success = SnapdealItem()
23611 
          self.success.read(iprot)
8739 vikram.rag 23612 
        else:
23613 
          iprot.skip(ftype)
23614 
      else:
23615 
        iprot.skip(ftype)
23616 
      iprot.readFieldEnd()
23617 
    iprot.readStructEnd()
23618 
 
23619 
  def write(self, oprot):
23620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23622 
      return
9242 kshitij.so 23623 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 23624 
    if self.success is not None:
9242 kshitij.so 23625 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23626 
      self.success.write(oprot)
8739 vikram.rag 23627 
      oprot.writeFieldEnd()
23628 
    oprot.writeFieldStop()
23629 
    oprot.writeStructEnd()
23630 
 
23631 
  def validate(self):
23632 
    return
23633 
 
23634 
 
23635 
  def __repr__(self):
23636 
    L = ['%s=%r' % (key, value)
23637 
      for key, value in self.__dict__.iteritems()]
23638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23639 
 
23640 
  def __eq__(self, other):
23641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23642 
 
23643 
  def __ne__(self, other):
23644 
    return not (self == other)
23645 
 
9242 kshitij.so 23646 
class getSnapdealItemDetails_args:
8739 vikram.rag 23647 
  """
23648 
  Attributes:
23649 
   - item_id
23650 
  """
23651 
 
23652 
  thrift_spec = (
23653 
    None, # 0
23654 
    (1, TType.I64, 'item_id', None, None, ), # 1
23655 
  )
23656 
 
23657 
  def __init__(self, item_id=None,):
23658 
    self.item_id = item_id
23659 
 
23660 
  def read(self, iprot):
23661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23663 
      return
23664 
    iprot.readStructBegin()
23665 
    while True:
23666 
      (fname, ftype, fid) = iprot.readFieldBegin()
23667 
      if ftype == TType.STOP:
23668 
        break
23669 
      if fid == 1:
23670 
        if ftype == TType.I64:
23671 
          self.item_id = iprot.readI64();
23672 
        else:
23673 
          iprot.skip(ftype)
23674 
      else:
23675 
        iprot.skip(ftype)
23676 
      iprot.readFieldEnd()
23677 
    iprot.readStructEnd()
23678 
 
23679 
  def write(self, oprot):
23680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23682 
      return
9242 kshitij.so 23683 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 23684 
    if self.item_id is not None:
23685 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23686 
      oprot.writeI64(self.item_id)
23687 
      oprot.writeFieldEnd()
23688 
    oprot.writeFieldStop()
23689 
    oprot.writeStructEnd()
23690 
 
23691 
  def validate(self):
23692 
    return
23693 
 
23694 
 
23695 
  def __repr__(self):
23696 
    L = ['%s=%r' % (key, value)
23697 
      for key, value in self.__dict__.iteritems()]
23698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23699 
 
23700 
  def __eq__(self, other):
23701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23702 
 
23703 
  def __ne__(self, other):
23704 
    return not (self == other)
23705 
 
9242 kshitij.so 23706 
class getSnapdealItemDetails_result:
8739 vikram.rag 23707 
  """
23708 
  Attributes:
23709 
   - success
23710 
  """
23711 
 
23712 
  thrift_spec = (
9242 kshitij.so 23713 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 23714 
  )
23715 
 
23716 
  def __init__(self, success=None,):
23717 
    self.success = success
23718 
 
23719 
  def read(self, iprot):
23720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23722 
      return
23723 
    iprot.readStructBegin()
23724 
    while True:
23725 
      (fname, ftype, fid) = iprot.readFieldBegin()
23726 
      if ftype == TType.STOP:
23727 
        break
23728 
      if fid == 0:
23729 
        if ftype == TType.STRUCT:
9242 kshitij.so 23730 
          self.success = SnapdealItemDetails()
8739 vikram.rag 23731 
          self.success.read(iprot)
23732 
        else:
23733 
          iprot.skip(ftype)
23734 
      else:
23735 
        iprot.skip(ftype)
23736 
      iprot.readFieldEnd()
23737 
    iprot.readStructEnd()
23738 
 
23739 
  def write(self, oprot):
23740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23742 
      return
9242 kshitij.so 23743 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 23744 
    if self.success is not None:
23745 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23746 
      self.success.write(oprot)
23747 
      oprot.writeFieldEnd()
23748 
    oprot.writeFieldStop()
23749 
    oprot.writeStructEnd()
23750 
 
23751 
  def validate(self):
23752 
    return
23753 
 
23754 
 
23755 
  def __repr__(self):
23756 
    L = ['%s=%r' % (key, value)
23757 
      for key, value in self.__dict__.iteritems()]
23758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23759 
 
23760 
  def __eq__(self, other):
23761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23762 
 
23763 
  def __ne__(self, other):
23764 
    return not (self == other)
23765 
 
23766 
class getAllSnapdealItems_args:
23767 
 
23768 
  thrift_spec = (
23769 
  )
23770 
 
23771 
  def read(self, iprot):
23772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23774 
      return
23775 
    iprot.readStructBegin()
23776 
    while True:
23777 
      (fname, ftype, fid) = iprot.readFieldBegin()
23778 
      if ftype == TType.STOP:
23779 
        break
23780 
      else:
23781 
        iprot.skip(ftype)
23782 
      iprot.readFieldEnd()
23783 
    iprot.readStructEnd()
23784 
 
23785 
  def write(self, oprot):
23786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23788 
      return
23789 
    oprot.writeStructBegin('getAllSnapdealItems_args')
23790 
    oprot.writeFieldStop()
23791 
    oprot.writeStructEnd()
23792 
 
23793 
  def validate(self):
23794 
    return
23795 
 
23796 
 
23797 
  def __repr__(self):
23798 
    L = ['%s=%r' % (key, value)
23799 
      for key, value in self.__dict__.iteritems()]
23800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23801 
 
23802 
  def __eq__(self, other):
23803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23804 
 
23805 
  def __ne__(self, other):
23806 
    return not (self == other)
23807 
 
23808 
class getAllSnapdealItems_result:
23809 
  """
23810 
  Attributes:
23811 
   - success
23812 
  """
23813 
 
23814 
  thrift_spec = (
9242 kshitij.so 23815 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 23816 
  )
23817 
 
23818 
  def __init__(self, success=None,):
23819 
    self.success = success
23820 
 
23821 
  def read(self, iprot):
23822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23824 
      return
23825 
    iprot.readStructBegin()
23826 
    while True:
23827 
      (fname, ftype, fid) = iprot.readFieldBegin()
23828 
      if ftype == TType.STOP:
23829 
        break
23830 
      if fid == 0:
23831 
        if ftype == TType.LIST:
23832 
          self.success = []
9242 kshitij.so 23833 
          (_etype516, _size513) = iprot.readListBegin()
23834 
          for _i517 in xrange(_size513):
23835 
            _elem518 = SnapdealItemDetails()
23836 
            _elem518.read(iprot)
23837 
            self.success.append(_elem518)
23838 
          iprot.readListEnd()
23839 
        else:
23840 
          iprot.skip(ftype)
23841 
      else:
23842 
        iprot.skip(ftype)
23843 
      iprot.readFieldEnd()
23844 
    iprot.readStructEnd()
23845 
 
23846 
  def write(self, oprot):
23847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23849 
      return
23850 
    oprot.writeStructBegin('getAllSnapdealItems_result')
23851 
    if self.success is not None:
23852 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23853 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23854 
      for iter519 in self.success:
23855 
        iter519.write(oprot)
23856 
      oprot.writeListEnd()
23857 
      oprot.writeFieldEnd()
23858 
    oprot.writeFieldStop()
23859 
    oprot.writeStructEnd()
23860 
 
23861 
  def validate(self):
23862 
    return
23863 
 
23864 
 
23865 
  def __repr__(self):
23866 
    L = ['%s=%r' % (key, value)
23867 
      for key, value in self.__dict__.iteritems()]
23868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23869 
 
23870 
  def __eq__(self, other):
23871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23872 
 
23873 
  def __ne__(self, other):
23874 
    return not (self == other)
23875 
 
23876 
class getSnapdealItems_args:
23877 
  """
23878 
  Attributes:
23879 
   - offset
23880 
   - limit
23881 
  """
23882 
 
23883 
  thrift_spec = (
23884 
    None, # 0
23885 
    (1, TType.I64, 'offset', None, None, ), # 1
23886 
    (2, TType.I64, 'limit', None, None, ), # 2
23887 
  )
23888 
 
23889 
  def __init__(self, offset=None, limit=None,):
23890 
    self.offset = offset
23891 
    self.limit = limit
23892 
 
23893 
  def read(self, iprot):
23894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23896 
      return
23897 
    iprot.readStructBegin()
23898 
    while True:
23899 
      (fname, ftype, fid) = iprot.readFieldBegin()
23900 
      if ftype == TType.STOP:
23901 
        break
23902 
      if fid == 1:
23903 
        if ftype == TType.I64:
23904 
          self.offset = iprot.readI64();
23905 
        else:
23906 
          iprot.skip(ftype)
23907 
      elif fid == 2:
23908 
        if ftype == TType.I64:
23909 
          self.limit = iprot.readI64();
23910 
        else:
23911 
          iprot.skip(ftype)
23912 
      else:
23913 
        iprot.skip(ftype)
23914 
      iprot.readFieldEnd()
23915 
    iprot.readStructEnd()
23916 
 
23917 
  def write(self, oprot):
23918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23920 
      return
23921 
    oprot.writeStructBegin('getSnapdealItems_args')
23922 
    if self.offset is not None:
23923 
      oprot.writeFieldBegin('offset', TType.I64, 1)
23924 
      oprot.writeI64(self.offset)
23925 
      oprot.writeFieldEnd()
23926 
    if self.limit is not None:
23927 
      oprot.writeFieldBegin('limit', TType.I64, 2)
23928 
      oprot.writeI64(self.limit)
23929 
      oprot.writeFieldEnd()
23930 
    oprot.writeFieldStop()
23931 
    oprot.writeStructEnd()
23932 
 
23933 
  def validate(self):
23934 
    return
23935 
 
23936 
 
23937 
  def __repr__(self):
23938 
    L = ['%s=%r' % (key, value)
23939 
      for key, value in self.__dict__.iteritems()]
23940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23941 
 
23942 
  def __eq__(self, other):
23943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23944 
 
23945 
  def __ne__(self, other):
23946 
    return not (self == other)
23947 
 
23948 
class getSnapdealItems_result:
23949 
  """
23950 
  Attributes:
23951 
   - success
23952 
  """
23953 
 
23954 
  thrift_spec = (
23955 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23956 
  )
23957 
 
23958 
  def __init__(self, success=None,):
23959 
    self.success = success
23960 
 
23961 
  def read(self, iprot):
23962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23964 
      return
23965 
    iprot.readStructBegin()
23966 
    while True:
23967 
      (fname, ftype, fid) = iprot.readFieldBegin()
23968 
      if ftype == TType.STOP:
23969 
        break
23970 
      if fid == 0:
23971 
        if ftype == TType.LIST:
23972 
          self.success = []
9155 kshitij.so 23973 
          (_etype523, _size520) = iprot.readListBegin()
23974 
          for _i524 in xrange(_size520):
9242 kshitij.so 23975 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 23976 
            _elem525.read(iprot)
23977 
            self.success.append(_elem525)
8739 vikram.rag 23978 
          iprot.readListEnd()
23979 
        else:
23980 
          iprot.skip(ftype)
23981 
      else:
23982 
        iprot.skip(ftype)
23983 
      iprot.readFieldEnd()
23984 
    iprot.readStructEnd()
23985 
 
23986 
  def write(self, oprot):
23987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23989 
      return
9242 kshitij.so 23990 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 23991 
    if self.success is not None:
23992 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23993 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23994 
      for iter526 in self.success:
23995 
        iter526.write(oprot)
8739 vikram.rag 23996 
      oprot.writeListEnd()
23997 
      oprot.writeFieldEnd()
23998 
    oprot.writeFieldStop()
23999 
    oprot.writeStructEnd()
24000 
 
24001 
  def validate(self):
24002 
    return
24003 
 
24004 
 
24005 
  def __repr__(self):
24006 
    L = ['%s=%r' % (key, value)
24007 
      for key, value in self.__dict__.iteritems()]
24008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24009 
 
24010 
  def __eq__(self, other):
24011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24012 
 
24013 
  def __ne__(self, other):
24014 
    return not (self == other)
9242 kshitij.so 24015 
 
24016 
class searchSnapdealItems_args:
24017 
  """
24018 
  Attributes:
24019 
   - searchTerm
24020 
   - offset
24021 
   - limit
24022 
  """
24023 
 
24024 
  thrift_spec = (
24025 
    None, # 0
24026 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
24027 
    (2, TType.I64, 'offset', None, None, ), # 2
24028 
    (3, TType.I64, 'limit', None, None, ), # 3
24029 
  )
24030 
 
24031 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
24032 
    self.searchTerm = searchTerm
24033 
    self.offset = offset
24034 
    self.limit = limit
24035 
 
24036 
  def read(self, iprot):
24037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24039 
      return
24040 
    iprot.readStructBegin()
24041 
    while True:
24042 
      (fname, ftype, fid) = iprot.readFieldBegin()
24043 
      if ftype == TType.STOP:
24044 
        break
24045 
      if fid == 1:
24046 
        if ftype == TType.LIST:
24047 
          self.searchTerm = []
24048 
          (_etype530, _size527) = iprot.readListBegin()
24049 
          for _i531 in xrange(_size527):
24050 
            _elem532 = iprot.readString();
24051 
            self.searchTerm.append(_elem532)
24052 
          iprot.readListEnd()
24053 
        else:
24054 
          iprot.skip(ftype)
24055 
      elif fid == 2:
24056 
        if ftype == TType.I64:
24057 
          self.offset = iprot.readI64();
24058 
        else:
24059 
          iprot.skip(ftype)
24060 
      elif fid == 3:
24061 
        if ftype == TType.I64:
24062 
          self.limit = iprot.readI64();
24063 
        else:
24064 
          iprot.skip(ftype)
24065 
      else:
24066 
        iprot.skip(ftype)
24067 
      iprot.readFieldEnd()
24068 
    iprot.readStructEnd()
24069 
 
24070 
  def write(self, oprot):
24071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24073 
      return
24074 
    oprot.writeStructBegin('searchSnapdealItems_args')
24075 
    if self.searchTerm is not None:
24076 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
24077 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
24078 
      for iter533 in self.searchTerm:
24079 
        oprot.writeString(iter533)
24080 
      oprot.writeListEnd()
24081 
      oprot.writeFieldEnd()
24082 
    if self.offset is not None:
24083 
      oprot.writeFieldBegin('offset', TType.I64, 2)
24084 
      oprot.writeI64(self.offset)
24085 
      oprot.writeFieldEnd()
24086 
    if self.limit is not None:
24087 
      oprot.writeFieldBegin('limit', TType.I64, 3)
24088 
      oprot.writeI64(self.limit)
24089 
      oprot.writeFieldEnd()
24090 
    oprot.writeFieldStop()
24091 
    oprot.writeStructEnd()
24092 
 
24093 
  def validate(self):
24094 
    return
24095 
 
24096 
 
24097 
  def __repr__(self):
24098 
    L = ['%s=%r' % (key, value)
24099 
      for key, value in self.__dict__.iteritems()]
24100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24101 
 
24102 
  def __eq__(self, other):
24103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24104 
 
24105 
  def __ne__(self, other):
24106 
    return not (self == other)
24107 
 
24108 
class searchSnapdealItems_result:
24109 
  """
24110 
  Attributes:
24111 
   - success
24112 
  """
24113 
 
24114 
  thrift_spec = (
24115 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
24116 
  )
24117 
 
24118 
  def __init__(self, success=None,):
24119 
    self.success = success
24120 
 
24121 
  def read(self, iprot):
24122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24124 
      return
24125 
    iprot.readStructBegin()
24126 
    while True:
24127 
      (fname, ftype, fid) = iprot.readFieldBegin()
24128 
      if ftype == TType.STOP:
24129 
        break
24130 
      if fid == 0:
24131 
        if ftype == TType.LIST:
24132 
          self.success = []
24133 
          (_etype537, _size534) = iprot.readListBegin()
24134 
          for _i538 in xrange(_size534):
24135 
            _elem539 = SnapdealItemDetails()
24136 
            _elem539.read(iprot)
24137 
            self.success.append(_elem539)
24138 
          iprot.readListEnd()
24139 
        else:
24140 
          iprot.skip(ftype)
24141 
      else:
24142 
        iprot.skip(ftype)
24143 
      iprot.readFieldEnd()
24144 
    iprot.readStructEnd()
24145 
 
24146 
  def write(self, oprot):
24147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24149 
      return
24150 
    oprot.writeStructBegin('searchSnapdealItems_result')
24151 
    if self.success is not None:
24152 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24153 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24154 
      for iter540 in self.success:
24155 
        iter540.write(oprot)
24156 
      oprot.writeListEnd()
24157 
      oprot.writeFieldEnd()
24158 
    oprot.writeFieldStop()
24159 
    oprot.writeStructEnd()
24160 
 
24161 
  def validate(self):
24162 
    return
24163 
 
24164 
 
24165 
  def __repr__(self):
24166 
    L = ['%s=%r' % (key, value)
24167 
      for key, value in self.__dict__.iteritems()]
24168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24169 
 
24170 
  def __eq__(self, other):
24171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24172 
 
24173 
  def __ne__(self, other):
24174 
    return not (self == other)
24175 
 
24176 
class getCountForSnapdealItems_args:
24177 
 
24178 
  thrift_spec = (
24179 
  )
24180 
 
24181 
  def read(self, iprot):
24182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24184 
      return
24185 
    iprot.readStructBegin()
24186 
    while True:
24187 
      (fname, ftype, fid) = iprot.readFieldBegin()
24188 
      if ftype == TType.STOP:
24189 
        break
24190 
      else:
24191 
        iprot.skip(ftype)
24192 
      iprot.readFieldEnd()
24193 
    iprot.readStructEnd()
24194 
 
24195 
  def write(self, oprot):
24196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24198 
      return
24199 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
24200 
    oprot.writeFieldStop()
24201 
    oprot.writeStructEnd()
24202 
 
24203 
  def validate(self):
24204 
    return
24205 
 
24206 
 
24207 
  def __repr__(self):
24208 
    L = ['%s=%r' % (key, value)
24209 
      for key, value in self.__dict__.iteritems()]
24210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24211 
 
24212 
  def __eq__(self, other):
24213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24214 
 
24215 
  def __ne__(self, other):
24216 
    return not (self == other)
24217 
 
24218 
class getCountForSnapdealItems_result:
24219 
  """
24220 
  Attributes:
24221 
   - success
24222 
  """
24223 
 
24224 
  thrift_spec = (
24225 
    (0, TType.I64, 'success', None, None, ), # 0
24226 
  )
24227 
 
24228 
  def __init__(self, success=None,):
24229 
    self.success = success
24230 
 
24231 
  def read(self, iprot):
24232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24234 
      return
24235 
    iprot.readStructBegin()
24236 
    while True:
24237 
      (fname, ftype, fid) = iprot.readFieldBegin()
24238 
      if ftype == TType.STOP:
24239 
        break
24240 
      if fid == 0:
24241 
        if ftype == TType.I64:
24242 
          self.success = iprot.readI64();
24243 
        else:
24244 
          iprot.skip(ftype)
24245 
      else:
24246 
        iprot.skip(ftype)
24247 
      iprot.readFieldEnd()
24248 
    iprot.readStructEnd()
24249 
 
24250 
  def write(self, oprot):
24251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24253 
      return
24254 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
24255 
    if self.success is not None:
24256 
      oprot.writeFieldBegin('success', TType.I64, 0)
24257 
      oprot.writeI64(self.success)
24258 
      oprot.writeFieldEnd()
24259 
    oprot.writeFieldStop()
24260 
    oprot.writeStructEnd()
24261 
 
24262 
  def validate(self):
24263 
    return
24264 
 
24265 
 
24266 
  def __repr__(self):
24267 
    L = ['%s=%r' % (key, value)
24268 
      for key, value in self.__dict__.iteritems()]
24269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24270 
 
24271 
  def __eq__(self, other):
24272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24273 
 
24274 
  def __ne__(self, other):
24275 
    return not (self == other)
24276 
 
24277 
class getSnapdealSearchResultCount_args:
24278 
  """
24279 
  Attributes:
24280 
   - searchTerm
24281 
  """
24282 
 
24283 
  thrift_spec = (
24284 
    None, # 0
24285 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
24286 
  )
24287 
 
24288 
  def __init__(self, searchTerm=None,):
24289 
    self.searchTerm = searchTerm
24290 
 
24291 
  def read(self, iprot):
24292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24294 
      return
24295 
    iprot.readStructBegin()
24296 
    while True:
24297 
      (fname, ftype, fid) = iprot.readFieldBegin()
24298 
      if ftype == TType.STOP:
24299 
        break
24300 
      if fid == 1:
24301 
        if ftype == TType.LIST:
24302 
          self.searchTerm = []
24303 
          (_etype544, _size541) = iprot.readListBegin()
24304 
          for _i545 in xrange(_size541):
24305 
            _elem546 = iprot.readString();
24306 
            self.searchTerm.append(_elem546)
24307 
          iprot.readListEnd()
24308 
        else:
24309 
          iprot.skip(ftype)
24310 
      else:
24311 
        iprot.skip(ftype)
24312 
      iprot.readFieldEnd()
24313 
    iprot.readStructEnd()
24314 
 
24315 
  def write(self, oprot):
24316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24318 
      return
24319 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
24320 
    if self.searchTerm is not None:
24321 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
24322 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
24323 
      for iter547 in self.searchTerm:
24324 
        oprot.writeString(iter547)
24325 
      oprot.writeListEnd()
24326 
      oprot.writeFieldEnd()
24327 
    oprot.writeFieldStop()
24328 
    oprot.writeStructEnd()
24329 
 
24330 
  def validate(self):
24331 
    return
24332 
 
24333 
 
24334 
  def __repr__(self):
24335 
    L = ['%s=%r' % (key, value)
24336 
      for key, value in self.__dict__.iteritems()]
24337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24338 
 
24339 
  def __eq__(self, other):
24340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24341 
 
24342 
  def __ne__(self, other):
24343 
    return not (self == other)
24344 
 
24345 
class getSnapdealSearchResultCount_result:
24346 
  """
24347 
  Attributes:
24348 
   - success
24349 
  """
24350 
 
24351 
  thrift_spec = (
24352 
    (0, TType.I64, 'success', None, None, ), # 0
24353 
  )
24354 
 
24355 
  def __init__(self, success=None,):
24356 
    self.success = success
24357 
 
24358 
  def read(self, iprot):
24359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24361 
      return
24362 
    iprot.readStructBegin()
24363 
    while True:
24364 
      (fname, ftype, fid) = iprot.readFieldBegin()
24365 
      if ftype == TType.STOP:
24366 
        break
24367 
      if fid == 0:
24368 
        if ftype == TType.I64:
24369 
          self.success = iprot.readI64();
24370 
        else:
24371 
          iprot.skip(ftype)
24372 
      else:
24373 
        iprot.skip(ftype)
24374 
      iprot.readFieldEnd()
24375 
    iprot.readStructEnd()
24376 
 
24377 
  def write(self, oprot):
24378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24380 
      return
24381 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
24382 
    if self.success is not None:
24383 
      oprot.writeFieldBegin('success', TType.I64, 0)
24384 
      oprot.writeI64(self.success)
24385 
      oprot.writeFieldEnd()
24386 
    oprot.writeFieldStop()
24387 
    oprot.writeStructEnd()
24388 
 
24389 
  def validate(self):
24390 
    return
24391 
 
24392 
 
24393 
  def __repr__(self):
24394 
    L = ['%s=%r' % (key, value)
24395 
      for key, value in self.__dict__.iteritems()]
24396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24397 
 
24398 
  def __eq__(self, other):
24399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24400 
 
24401 
  def __ne__(self, other):
24402 
    return not (self == other)
9299 kshitij.so 24403 
 
24404 
class getPrefferedInsurerForItem_args:
24405 
  """
24406 
  Attributes:
24407 
   - itemId
24408 
   - insurerType
24409 
  """
24410 
 
24411 
  thrift_spec = (
24412 
    None, # 0
24413 
    (1, TType.I64, 'itemId', None, None, ), # 1
24414 
    (2, TType.I32, 'insurerType', None, None, ), # 2
24415 
  )
24416 
 
24417 
  def __init__(self, itemId=None, insurerType=None,):
24418 
    self.itemId = itemId
24419 
    self.insurerType = insurerType
24420 
 
24421 
  def read(self, iprot):
24422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24424 
      return
24425 
    iprot.readStructBegin()
24426 
    while True:
24427 
      (fname, ftype, fid) = iprot.readFieldBegin()
24428 
      if ftype == TType.STOP:
24429 
        break
24430 
      if fid == 1:
24431 
        if ftype == TType.I64:
24432 
          self.itemId = iprot.readI64();
24433 
        else:
24434 
          iprot.skip(ftype)
24435 
      elif fid == 2:
24436 
        if ftype == TType.I32:
24437 
          self.insurerType = iprot.readI32();
24438 
        else:
24439 
          iprot.skip(ftype)
24440 
      else:
24441 
        iprot.skip(ftype)
24442 
      iprot.readFieldEnd()
24443 
    iprot.readStructEnd()
24444 
 
24445 
  def write(self, oprot):
24446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24448 
      return
24449 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
24450 
    if self.itemId is not None:
24451 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24452 
      oprot.writeI64(self.itemId)
24453 
      oprot.writeFieldEnd()
24454 
    if self.insurerType is not None:
24455 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
24456 
      oprot.writeI32(self.insurerType)
24457 
      oprot.writeFieldEnd()
24458 
    oprot.writeFieldStop()
24459 
    oprot.writeStructEnd()
24460 
 
24461 
  def validate(self):
24462 
    return
24463 
 
24464 
 
24465 
  def __repr__(self):
24466 
    L = ['%s=%r' % (key, value)
24467 
      for key, value in self.__dict__.iteritems()]
24468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24469 
 
24470 
  def __eq__(self, other):
24471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24472 
 
24473 
  def __ne__(self, other):
24474 
    return not (self == other)
24475 
 
24476 
class getPrefferedInsurerForItem_result:
24477 
  """
24478 
  Attributes:
24479 
   - success
24480 
  """
24481 
 
24482 
  thrift_spec = (
24483 
    (0, TType.I64, 'success', None, None, ), # 0
24484 
  )
24485 
 
24486 
  def __init__(self, success=None,):
24487 
    self.success = success
24488 
 
24489 
  def read(self, iprot):
24490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24492 
      return
24493 
    iprot.readStructBegin()
24494 
    while True:
24495 
      (fname, ftype, fid) = iprot.readFieldBegin()
24496 
      if ftype == TType.STOP:
24497 
        break
24498 
      if fid == 0:
24499 
        if ftype == TType.I64:
24500 
          self.success = iprot.readI64();
24501 
        else:
24502 
          iprot.skip(ftype)
24503 
      else:
24504 
        iprot.skip(ftype)
24505 
      iprot.readFieldEnd()
24506 
    iprot.readStructEnd()
24507 
 
24508 
  def write(self, oprot):
24509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24511 
      return
24512 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
24513 
    if self.success is not None:
24514 
      oprot.writeFieldBegin('success', TType.I64, 0)
24515 
      oprot.writeI64(self.success)
24516 
      oprot.writeFieldEnd()
24517 
    oprot.writeFieldStop()
24518 
    oprot.writeStructEnd()
24519 
 
24520 
  def validate(self):
24521 
    return
24522 
 
24523 
 
24524 
  def __repr__(self):
24525 
    L = ['%s=%r' % (key, value)
24526 
      for key, value in self.__dict__.iteritems()]
24527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24528 
 
24529 
  def __eq__(self, other):
24530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24531 
 
24532 
  def __ne__(self, other):
24533 
    return not (self == other)
9456 vikram.rag 24534 
 
24535 
class getSnapdealItembySkuAtSnapdeal_args:
24536 
  """
24537 
  Attributes:
24538 
   - skuAtSnapdeal
24539 
  """
24540 
 
24541 
  thrift_spec = None
24542 
  def __init__(self, skuAtSnapdeal=None,):
24543 
    self.skuAtSnapdeal = skuAtSnapdeal
24544 
 
24545 
  def read(self, iprot):
24546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24548 
      return
24549 
    iprot.readStructBegin()
24550 
    while True:
24551 
      (fname, ftype, fid) = iprot.readFieldBegin()
24552 
      if ftype == TType.STOP:
24553 
        break
24554 
      if fid == -1:
24555 
        if ftype == TType.STRING:
24556 
          self.skuAtSnapdeal = iprot.readString();
24557 
        else:
24558 
          iprot.skip(ftype)
24559 
      else:
24560 
        iprot.skip(ftype)
24561 
      iprot.readFieldEnd()
24562 
    iprot.readStructEnd()
24563 
 
24564 
  def write(self, oprot):
24565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24567 
      return
24568 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
24569 
    if self.skuAtSnapdeal is not None:
24570 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
24571 
      oprot.writeString(self.skuAtSnapdeal)
24572 
      oprot.writeFieldEnd()
24573 
    oprot.writeFieldStop()
24574 
    oprot.writeStructEnd()
24575 
 
24576 
  def validate(self):
24577 
    return
24578 
 
24579 
 
24580 
  def __repr__(self):
24581 
    L = ['%s=%r' % (key, value)
24582 
      for key, value in self.__dict__.iteritems()]
24583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24584 
 
24585 
  def __eq__(self, other):
24586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24587 
 
24588 
  def __ne__(self, other):
24589 
    return not (self == other)
24590 
 
24591 
class getSnapdealItembySkuAtSnapdeal_result:
24592 
  """
24593 
  Attributes:
24594 
   - success
24595 
  """
24596 
 
24597 
  thrift_spec = (
24598 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
24599 
  )
24600 
 
24601 
  def __init__(self, success=None,):
24602 
    self.success = success
24603 
 
24604 
  def read(self, iprot):
24605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24607 
      return
24608 
    iprot.readStructBegin()
24609 
    while True:
24610 
      (fname, ftype, fid) = iprot.readFieldBegin()
24611 
      if ftype == TType.STOP:
24612 
        break
24613 
      if fid == 0:
24614 
        if ftype == TType.STRUCT:
24615 
          self.success = SnapdealItem()
24616 
          self.success.read(iprot)
24617 
        else:
24618 
          iprot.skip(ftype)
24619 
      else:
24620 
        iprot.skip(ftype)
24621 
      iprot.readFieldEnd()
24622 
    iprot.readStructEnd()
24623 
 
24624 
  def write(self, oprot):
24625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24627 
      return
24628 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
24629 
    if self.success is not None:
24630 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24631 
      self.success.write(oprot)
24632 
      oprot.writeFieldEnd()
24633 
    oprot.writeFieldStop()
24634 
    oprot.writeStructEnd()
24635 
 
24636 
  def validate(self):
24637 
    return
24638 
 
24639 
 
24640 
  def __repr__(self):
24641 
    L = ['%s=%r' % (key, value)
24642 
      for key, value in self.__dict__.iteritems()]
24643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24644 
 
24645 
  def __eq__(self, other):
24646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24647 
 
24648 
  def __ne__(self, other):
24649 
    return not (self == other)
9621 manish.sha 24650 
 
24651 
class getProductFeedSubmit_args:
24652 
  """
24653 
  Attributes:
24654 
   - catalogItemId
24655 
  """
24656 
 
24657 
  thrift_spec = (
24658 
    None, # 0
24659 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24660 
  )
24661 
 
24662 
  def __init__(self, catalogItemId=None,):
24663 
    self.catalogItemId = catalogItemId
24664 
 
24665 
  def read(self, iprot):
24666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24668 
      return
24669 
    iprot.readStructBegin()
24670 
    while True:
24671 
      (fname, ftype, fid) = iprot.readFieldBegin()
24672 
      if ftype == TType.STOP:
24673 
        break
24674 
      if fid == 1:
24675 
        if ftype == TType.I64:
24676 
          self.catalogItemId = iprot.readI64();
24677 
        else:
24678 
          iprot.skip(ftype)
24679 
      else:
24680 
        iprot.skip(ftype)
24681 
      iprot.readFieldEnd()
24682 
    iprot.readStructEnd()
24683 
 
24684 
  def write(self, oprot):
24685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24687 
      return
24688 
    oprot.writeStructBegin('getProductFeedSubmit_args')
24689 
    if self.catalogItemId is not None:
24690 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24691 
      oprot.writeI64(self.catalogItemId)
24692 
      oprot.writeFieldEnd()
24693 
    oprot.writeFieldStop()
24694 
    oprot.writeStructEnd()
24695 
 
24696 
  def validate(self):
24697 
    return
24698 
 
24699 
 
24700 
  def __repr__(self):
24701 
    L = ['%s=%r' % (key, value)
24702 
      for key, value in self.__dict__.iteritems()]
24703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24704 
 
24705 
  def __eq__(self, other):
24706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24707 
 
24708 
  def __ne__(self, other):
24709 
    return not (self == other)
24710 
 
24711 
class getProductFeedSubmit_result:
24712 
  """
24713 
  Attributes:
24714 
   - success
24715 
   - cex
24716 
  """
24717 
 
24718 
  thrift_spec = (
24719 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
24720 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24721 
  )
24722 
 
24723 
  def __init__(self, success=None, cex=None,):
24724 
    self.success = success
24725 
    self.cex = cex
24726 
 
24727 
  def read(self, iprot):
24728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24730 
      return
24731 
    iprot.readStructBegin()
24732 
    while True:
24733 
      (fname, ftype, fid) = iprot.readFieldBegin()
24734 
      if ftype == TType.STOP:
24735 
        break
24736 
      if fid == 0:
24737 
        if ftype == TType.STRUCT:
24738 
          self.success = ProductFeedSubmit()
24739 
          self.success.read(iprot)
24740 
        else:
24741 
          iprot.skip(ftype)
24742 
      elif fid == 1:
24743 
        if ftype == TType.STRUCT:
24744 
          self.cex = CatalogServiceException()
24745 
          self.cex.read(iprot)
24746 
        else:
24747 
          iprot.skip(ftype)
24748 
      else:
24749 
        iprot.skip(ftype)
24750 
      iprot.readFieldEnd()
24751 
    iprot.readStructEnd()
24752 
 
24753 
  def write(self, oprot):
24754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24756 
      return
24757 
    oprot.writeStructBegin('getProductFeedSubmit_result')
24758 
    if self.success is not None:
24759 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24760 
      self.success.write(oprot)
24761 
      oprot.writeFieldEnd()
24762 
    if self.cex is not None:
24763 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24764 
      self.cex.write(oprot)
24765 
      oprot.writeFieldEnd()
24766 
    oprot.writeFieldStop()
24767 
    oprot.writeStructEnd()
24768 
 
24769 
  def validate(self):
24770 
    return
24771 
 
24772 
 
24773 
  def __repr__(self):
24774 
    L = ['%s=%r' % (key, value)
24775 
      for key, value in self.__dict__.iteritems()]
24776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24777 
 
24778 
  def __eq__(self, other):
24779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24780 
 
24781 
  def __ne__(self, other):
24782 
    return not (self == other)
24783 
 
24784 
class addProductFeedSubmit_args:
24785 
  """
24786 
  Attributes:
24787 
   - productFeedSubmit
24788 
  """
24789 
 
24790 
  thrift_spec = (
24791 
    None, # 0
24792 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24793 
  )
24794 
 
24795 
  def __init__(self, productFeedSubmit=None,):
24796 
    self.productFeedSubmit = productFeedSubmit
24797 
 
24798 
  def read(self, iprot):
24799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24801 
      return
24802 
    iprot.readStructBegin()
24803 
    while True:
24804 
      (fname, ftype, fid) = iprot.readFieldBegin()
24805 
      if ftype == TType.STOP:
24806 
        break
24807 
      if fid == 1:
24808 
        if ftype == TType.STRUCT:
24809 
          self.productFeedSubmit = ProductFeedSubmit()
24810 
          self.productFeedSubmit.read(iprot)
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('addProductFeedSubmit_args')
24823 
    if self.productFeedSubmit is not None:
24824 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24825 
      self.productFeedSubmit.write(oprot)
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)
24844 
 
24845 
class addProductFeedSubmit_result:
24846 
  """
24847 
  Attributes:
24848 
   - success
24849 
   - cex
24850 
  """
24851 
 
24852 
  thrift_spec = (
24853 
    (0, TType.BOOL, 'success', None, None, ), # 0
24854 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24855 
  )
24856 
 
24857 
  def __init__(self, success=None, cex=None,):
24858 
    self.success = success
24859 
    self.cex = cex
24860 
 
24861 
  def read(self, iprot):
24862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24864 
      return
24865 
    iprot.readStructBegin()
24866 
    while True:
24867 
      (fname, ftype, fid) = iprot.readFieldBegin()
24868 
      if ftype == TType.STOP:
24869 
        break
24870 
      if fid == 0:
24871 
        if ftype == TType.BOOL:
24872 
          self.success = iprot.readBool();
24873 
        else:
24874 
          iprot.skip(ftype)
24875 
      elif fid == 1:
24876 
        if ftype == TType.STRUCT:
24877 
          self.cex = CatalogServiceException()
24878 
          self.cex.read(iprot)
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('addProductFeedSubmit_result')
24891 
    if self.success is not None:
24892 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24893 
      oprot.writeBool(self.success)
24894 
      oprot.writeFieldEnd()
24895 
    if self.cex is not None:
24896 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24897 
      self.cex.write(oprot)
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 updateProductFeedSubmit_args:
24918 
  """
24919 
  Attributes:
24920 
   - productFeedSubmit
24921 
  """
24922 
 
24923 
  thrift_spec = (
24924 
    None, # 0
24925 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24926 
  )
24927 
 
24928 
  def __init__(self, productFeedSubmit=None,):
24929 
    self.productFeedSubmit = productFeedSubmit
24930 
 
24931 
  def read(self, iprot):
24932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24934 
      return
24935 
    iprot.readStructBegin()
24936 
    while True:
24937 
      (fname, ftype, fid) = iprot.readFieldBegin()
24938 
      if ftype == TType.STOP:
24939 
        break
24940 
      if fid == 1:
24941 
        if ftype == TType.STRUCT:
24942 
          self.productFeedSubmit = ProductFeedSubmit()
24943 
          self.productFeedSubmit.read(iprot)
24944 
        else:
24945 
          iprot.skip(ftype)
24946 
      else:
24947 
        iprot.skip(ftype)
24948 
      iprot.readFieldEnd()
24949 
    iprot.readStructEnd()
24950 
 
24951 
  def write(self, oprot):
24952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24954 
      return
24955 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
24956 
    if self.productFeedSubmit is not None:
24957 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24958 
      self.productFeedSubmit.write(oprot)
24959 
      oprot.writeFieldEnd()
24960 
    oprot.writeFieldStop()
24961 
    oprot.writeStructEnd()
24962 
 
24963 
  def validate(self):
24964 
    return
24965 
 
24966 
 
24967 
  def __repr__(self):
24968 
    L = ['%s=%r' % (key, value)
24969 
      for key, value in self.__dict__.iteritems()]
24970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24971 
 
24972 
  def __eq__(self, other):
24973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24974 
 
24975 
  def __ne__(self, other):
24976 
    return not (self == other)
24977 
 
24978 
class updateProductFeedSubmit_result:
24979 
  """
24980 
  Attributes:
24981 
   - success
24982 
   - cex
24983 
  """
24984 
 
24985 
  thrift_spec = (
24986 
    (0, TType.BOOL, 'success', None, None, ), # 0
24987 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24988 
  )
24989 
 
24990 
  def __init__(self, success=None, cex=None,):
24991 
    self.success = success
24992 
    self.cex = cex
24993 
 
24994 
  def read(self, iprot):
24995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24997 
      return
24998 
    iprot.readStructBegin()
24999 
    while True:
25000 
      (fname, ftype, fid) = iprot.readFieldBegin()
25001 
      if ftype == TType.STOP:
25002 
        break
25003 
      if fid == 0:
25004 
        if ftype == TType.BOOL:
25005 
          self.success = iprot.readBool();
25006 
        else:
25007 
          iprot.skip(ftype)
25008 
      elif fid == 1:
25009 
        if ftype == TType.STRUCT:
25010 
          self.cex = CatalogServiceException()
25011 
          self.cex.read(iprot)
25012 
        else:
25013 
          iprot.skip(ftype)
25014 
      else:
25015 
        iprot.skip(ftype)
25016 
      iprot.readFieldEnd()
25017 
    iprot.readStructEnd()
25018 
 
25019 
  def write(self, oprot):
25020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25022 
      return
25023 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
25024 
    if self.success is not None:
25025 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25026 
      oprot.writeBool(self.success)
25027 
      oprot.writeFieldEnd()
25028 
    if self.cex is not None:
25029 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25030 
      self.cex.write(oprot)
25031 
      oprot.writeFieldEnd()
25032 
    oprot.writeFieldStop()
25033 
    oprot.writeStructEnd()
25034 
 
25035 
  def validate(self):
25036 
    return
25037 
 
25038 
 
25039 
  def __repr__(self):
25040 
    L = ['%s=%r' % (key, value)
25041 
      for key, value in self.__dict__.iteritems()]
25042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25043 
 
25044 
  def __eq__(self, other):
25045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25046 
 
25047 
  def __ne__(self, other):
25048 
    return not (self == other)
25049 
 
25050 
class deleteProductFeedSubmit_args:
25051 
  """
25052 
  Attributes:
25053 
   - catalogItemId
25054 
  """
25055 
 
25056 
  thrift_spec = (
25057 
    None, # 0
25058 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
25059 
  )
25060 
 
25061 
  def __init__(self, catalogItemId=None,):
25062 
    self.catalogItemId = catalogItemId
25063 
 
25064 
  def read(self, iprot):
25065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25067 
      return
25068 
    iprot.readStructBegin()
25069 
    while True:
25070 
      (fname, ftype, fid) = iprot.readFieldBegin()
25071 
      if ftype == TType.STOP:
25072 
        break
25073 
      if fid == 1:
25074 
        if ftype == TType.I64:
25075 
          self.catalogItemId = iprot.readI64();
25076 
        else:
25077 
          iprot.skip(ftype)
25078 
      else:
25079 
        iprot.skip(ftype)
25080 
      iprot.readFieldEnd()
25081 
    iprot.readStructEnd()
25082 
 
25083 
  def write(self, oprot):
25084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25086 
      return
25087 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
25088 
    if self.catalogItemId is not None:
25089 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
25090 
      oprot.writeI64(self.catalogItemId)
25091 
      oprot.writeFieldEnd()
25092 
    oprot.writeFieldStop()
25093 
    oprot.writeStructEnd()
25094 
 
25095 
  def validate(self):
25096 
    return
25097 
 
25098 
 
25099 
  def __repr__(self):
25100 
    L = ['%s=%r' % (key, value)
25101 
      for key, value in self.__dict__.iteritems()]
25102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25103 
 
25104 
  def __eq__(self, other):
25105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25106 
 
25107 
  def __ne__(self, other):
25108 
    return not (self == other)
25109 
 
25110 
class deleteProductFeedSubmit_result:
25111 
  """
25112 
  Attributes:
25113 
   - success
25114 
   - cex
25115 
  """
25116 
 
25117 
  thrift_spec = (
25118 
    (0, TType.BOOL, 'success', None, None, ), # 0
25119 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25120 
  )
25121 
 
25122 
  def __init__(self, success=None, cex=None,):
25123 
    self.success = success
25124 
    self.cex = cex
25125 
 
25126 
  def read(self, iprot):
25127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25129 
      return
25130 
    iprot.readStructBegin()
25131 
    while True:
25132 
      (fname, ftype, fid) = iprot.readFieldBegin()
25133 
      if ftype == TType.STOP:
25134 
        break
25135 
      if fid == 0:
25136 
        if ftype == TType.BOOL:
25137 
          self.success = iprot.readBool();
25138 
        else:
25139 
          iprot.skip(ftype)
25140 
      elif fid == 1:
25141 
        if ftype == TType.STRUCT:
25142 
          self.cex = CatalogServiceException()
25143 
          self.cex.read(iprot)
25144 
        else:
25145 
          iprot.skip(ftype)
25146 
      else:
25147 
        iprot.skip(ftype)
25148 
      iprot.readFieldEnd()
25149 
    iprot.readStructEnd()
25150 
 
25151 
  def write(self, oprot):
25152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25154 
      return
25155 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
25156 
    if self.success is not None:
25157 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25158 
      oprot.writeBool(self.success)
25159 
      oprot.writeFieldEnd()
25160 
    if self.cex is not None:
25161 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25162 
      self.cex.write(oprot)
25163 
      oprot.writeFieldEnd()
25164 
    oprot.writeFieldStop()
25165 
    oprot.writeStructEnd()
25166 
 
25167 
  def validate(self):
25168 
    return
25169 
 
25170 
 
25171 
  def __repr__(self):
25172 
    L = ['%s=%r' % (key, value)
25173 
      for key, value in self.__dict__.iteritems()]
25174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25175 
 
25176 
  def __eq__(self, other):
25177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25178 
 
25179 
  def __ne__(self, other):
25180 
    return not (self == other)
25181 
 
25182 
class getAllProductFeedSubmit_args:
25183 
 
25184 
  thrift_spec = (
25185 
  )
25186 
 
25187 
  def read(self, iprot):
25188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25190 
      return
25191 
    iprot.readStructBegin()
25192 
    while True:
25193 
      (fname, ftype, fid) = iprot.readFieldBegin()
25194 
      if ftype == TType.STOP:
25195 
        break
25196 
      else:
25197 
        iprot.skip(ftype)
25198 
      iprot.readFieldEnd()
25199 
    iprot.readStructEnd()
25200 
 
25201 
  def write(self, oprot):
25202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25204 
      return
25205 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
25206 
    oprot.writeFieldStop()
25207 
    oprot.writeStructEnd()
25208 
 
25209 
  def validate(self):
25210 
    return
25211 
 
25212 
 
25213 
  def __repr__(self):
25214 
    L = ['%s=%r' % (key, value)
25215 
      for key, value in self.__dict__.iteritems()]
25216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25217 
 
25218 
  def __eq__(self, other):
25219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25220 
 
25221 
  def __ne__(self, other):
25222 
    return not (self == other)
25223 
 
25224 
class getAllProductFeedSubmit_result:
25225 
  """
25226 
  Attributes:
25227 
   - success
25228 
   - cex
25229 
  """
25230 
 
25231 
  thrift_spec = (
25232 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
25233 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25234 
  )
25235 
 
25236 
  def __init__(self, success=None, cex=None,):
25237 
    self.success = success
25238 
    self.cex = cex
25239 
 
25240 
  def read(self, iprot):
25241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25243 
      return
25244 
    iprot.readStructBegin()
25245 
    while True:
25246 
      (fname, ftype, fid) = iprot.readFieldBegin()
25247 
      if ftype == TType.STOP:
25248 
        break
25249 
      if fid == 0:
25250 
        if ftype == TType.LIST:
25251 
          self.success = []
25252 
          (_etype551, _size548) = iprot.readListBegin()
25253 
          for _i552 in xrange(_size548):
25254 
            _elem553 = ProductFeedSubmit()
25255 
            _elem553.read(iprot)
25256 
            self.success.append(_elem553)
25257 
          iprot.readListEnd()
25258 
        else:
25259 
          iprot.skip(ftype)
25260 
      elif fid == 1:
25261 
        if ftype == TType.STRUCT:
25262 
          self.cex = CatalogServiceException()
25263 
          self.cex.read(iprot)
25264 
        else:
25265 
          iprot.skip(ftype)
25266 
      else:
25267 
        iprot.skip(ftype)
25268 
      iprot.readFieldEnd()
25269 
    iprot.readStructEnd()
25270 
 
25271 
  def write(self, oprot):
25272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25274 
      return
25275 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
25276 
    if self.success is not None:
25277 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25278 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25279 
      for iter554 in self.success:
25280 
        iter554.write(oprot)
25281 
      oprot.writeListEnd()
25282 
      oprot.writeFieldEnd()
25283 
    if self.cex is not None:
25284 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25285 
      self.cex.write(oprot)
25286 
      oprot.writeFieldEnd()
25287 
    oprot.writeFieldStop()
25288 
    oprot.writeStructEnd()
25289 
 
25290 
  def validate(self):
25291 
    return
25292 
 
25293 
 
25294 
  def __repr__(self):
25295 
    L = ['%s=%r' % (key, value)
25296 
      for key, value in self.__dict__.iteritems()]
25297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25298 
 
25299 
  def __eq__(self, other):
25300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25301 
 
25302 
  def __ne__(self, other):
25303 
    return not (self == other)
9724 kshitij.so 25304 
 
25305 
class getMarketplacedetailsForItem_args:
25306 
  """
25307 
  Attributes:
25308 
   - itemId
25309 
   - sourceId
25310 
  """
25311 
 
25312 
  thrift_spec = (
25313 
    None, # 0
25314 
    (1, TType.I64, 'itemId', None, None, ), # 1
25315 
    (2, TType.I64, 'sourceId', None, None, ), # 2
25316 
  )
25317 
 
25318 
  def __init__(self, itemId=None, sourceId=None,):
25319 
    self.itemId = itemId
25320 
    self.sourceId = sourceId
25321 
 
25322 
  def read(self, iprot):
25323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25325 
      return
25326 
    iprot.readStructBegin()
25327 
    while True:
25328 
      (fname, ftype, fid) = iprot.readFieldBegin()
25329 
      if ftype == TType.STOP:
25330 
        break
25331 
      if fid == 1:
25332 
        if ftype == TType.I64:
25333 
          self.itemId = iprot.readI64();
25334 
        else:
25335 
          iprot.skip(ftype)
25336 
      elif fid == 2:
25337 
        if ftype == TType.I64:
25338 
          self.sourceId = iprot.readI64();
25339 
        else:
25340 
          iprot.skip(ftype)
25341 
      else:
25342 
        iprot.skip(ftype)
25343 
      iprot.readFieldEnd()
25344 
    iprot.readStructEnd()
25345 
 
25346 
  def write(self, oprot):
25347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25349 
      return
25350 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
25351 
    if self.itemId is not None:
25352 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25353 
      oprot.writeI64(self.itemId)
25354 
      oprot.writeFieldEnd()
25355 
    if self.sourceId is not None:
25356 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
25357 
      oprot.writeI64(self.sourceId)
25358 
      oprot.writeFieldEnd()
25359 
    oprot.writeFieldStop()
25360 
    oprot.writeStructEnd()
25361 
 
25362 
  def validate(self):
25363 
    return
25364 
 
25365 
 
25366 
  def __repr__(self):
25367 
    L = ['%s=%r' % (key, value)
25368 
      for key, value in self.__dict__.iteritems()]
25369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25370 
 
25371 
  def __eq__(self, other):
25372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25373 
 
25374 
  def __ne__(self, other):
25375 
    return not (self == other)
25376 
 
25377 
class getMarketplacedetailsForItem_result:
25378 
  """
25379 
  Attributes:
25380 
   - success
25381 
  """
25382 
 
25383 
  thrift_spec = (
25384 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
25385 
  )
25386 
 
25387 
  def __init__(self, success=None,):
25388 
    self.success = success
25389 
 
25390 
  def read(self, iprot):
25391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25393 
      return
25394 
    iprot.readStructBegin()
25395 
    while True:
25396 
      (fname, ftype, fid) = iprot.readFieldBegin()
25397 
      if ftype == TType.STOP:
25398 
        break
25399 
      if fid == 0:
25400 
        if ftype == TType.STRUCT:
25401 
          self.success = MarketplaceItems()
25402 
          self.success.read(iprot)
25403 
        else:
25404 
          iprot.skip(ftype)
25405 
      else:
25406 
        iprot.skip(ftype)
25407 
      iprot.readFieldEnd()
25408 
    iprot.readStructEnd()
25409 
 
25410 
  def write(self, oprot):
25411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25413 
      return
25414 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
25415 
    if self.success is not None:
25416 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25417 
      self.success.write(oprot)
25418 
      oprot.writeFieldEnd()
25419 
    oprot.writeFieldStop()
25420 
    oprot.writeStructEnd()
25421 
 
25422 
  def validate(self):
25423 
    return
25424 
 
25425 
 
25426 
  def __repr__(self):
25427 
    L = ['%s=%r' % (key, value)
25428 
      for key, value in self.__dict__.iteritems()]
25429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25430 
 
25431 
  def __eq__(self, other):
25432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25433 
 
25434 
  def __ne__(self, other):
25435 
    return not (self == other)
25436 
 
25437 
class updateMarketplaceAttributesForItem_args:
25438 
  """
25439 
  Attributes:
25440 
   - marketPlaceItem
25441 
  """
25442 
 
25443 
  thrift_spec = (
25444 
    None, # 0
25445 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
25446 
  )
25447 
 
25448 
  def __init__(self, marketPlaceItem=None,):
25449 
    self.marketPlaceItem = marketPlaceItem
25450 
 
25451 
  def read(self, iprot):
25452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25454 
      return
25455 
    iprot.readStructBegin()
25456 
    while True:
25457 
      (fname, ftype, fid) = iprot.readFieldBegin()
25458 
      if ftype == TType.STOP:
25459 
        break
25460 
      if fid == 1:
25461 
        if ftype == TType.STRUCT:
25462 
          self.marketPlaceItem = MarketplaceItems()
25463 
          self.marketPlaceItem.read(iprot)
25464 
        else:
25465 
          iprot.skip(ftype)
25466 
      else:
25467 
        iprot.skip(ftype)
25468 
      iprot.readFieldEnd()
25469 
    iprot.readStructEnd()
25470 
 
25471 
  def write(self, oprot):
25472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25474 
      return
25475 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
25476 
    if self.marketPlaceItem is not None:
25477 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
25478 
      self.marketPlaceItem.write(oprot)
25479 
      oprot.writeFieldEnd()
25480 
    oprot.writeFieldStop()
25481 
    oprot.writeStructEnd()
25482 
 
25483 
  def validate(self):
25484 
    return
25485 
 
25486 
 
25487 
  def __repr__(self):
25488 
    L = ['%s=%r' % (key, value)
25489 
      for key, value in self.__dict__.iteritems()]
25490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25491 
 
25492 
  def __eq__(self, other):
25493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25494 
 
25495 
  def __ne__(self, other):
25496 
    return not (self == other)
25497 
 
25498 
class updateMarketplaceAttributesForItem_result:
25499 
  """
25500 
  Attributes:
25501 
   - success
25502 
  """
25503 
 
25504 
  thrift_spec = (
25505 
    (0, TType.BOOL, 'success', None, None, ), # 0
25506 
  )
25507 
 
25508 
  def __init__(self, success=None,):
25509 
    self.success = success
25510 
 
25511 
  def read(self, iprot):
25512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25514 
      return
25515 
    iprot.readStructBegin()
25516 
    while True:
25517 
      (fname, ftype, fid) = iprot.readFieldBegin()
25518 
      if ftype == TType.STOP:
25519 
        break
25520 
      if fid == 0:
25521 
        if ftype == TType.BOOL:
25522 
          self.success = iprot.readBool();
25523 
        else:
25524 
          iprot.skip(ftype)
25525 
      else:
25526 
        iprot.skip(ftype)
25527 
      iprot.readFieldEnd()
25528 
    iprot.readStructEnd()
25529 
 
25530 
  def write(self, oprot):
25531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25533 
      return
25534 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
25535 
    if self.success is not None:
25536 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25537 
      oprot.writeBool(self.success)
25538 
      oprot.writeFieldEnd()
25539 
    oprot.writeFieldStop()
25540 
    oprot.writeStructEnd()
25541 
 
25542 
  def validate(self):
25543 
    return
25544 
 
25545 
 
25546 
  def __repr__(self):
25547 
    L = ['%s=%r' % (key, value)
25548 
      for key, value in self.__dict__.iteritems()]
25549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25550 
 
25551 
  def __eq__(self, other):
25552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25553 
 
25554 
  def __ne__(self, other):
25555 
    return not (self == other)
9776 vikram.rag 25556 
 
9779 kshitij.so 25557 
class getCostingForMarketplace_args:
25558 
  """
25559 
  Attributes:
25560 
   - source
25561 
   - item_id
25562 
  """
25563 
 
25564 
  thrift_spec = (
25565 
    None, # 0
25566 
    (1, TType.I64, 'source', None, None, ), # 1
25567 
    (2, TType.I64, 'item_id', None, None, ), # 2
25568 
  )
25569 
 
25570 
  def __init__(self, source=None, item_id=None,):
25571 
    self.source = source
25572 
    self.item_id = item_id
25573 
 
25574 
  def read(self, iprot):
25575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25577 
      return
25578 
    iprot.readStructBegin()
25579 
    while True:
25580 
      (fname, ftype, fid) = iprot.readFieldBegin()
25581 
      if ftype == TType.STOP:
25582 
        break
25583 
      if fid == 1:
25584 
        if ftype == TType.I64:
25585 
          self.source = iprot.readI64();
25586 
        else:
25587 
          iprot.skip(ftype)
25588 
      elif fid == 2:
25589 
        if ftype == TType.I64:
25590 
          self.item_id = iprot.readI64();
25591 
        else:
25592 
          iprot.skip(ftype)
25593 
      else:
25594 
        iprot.skip(ftype)
25595 
      iprot.readFieldEnd()
25596 
    iprot.readStructEnd()
25597 
 
25598 
  def write(self, oprot):
25599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25601 
      return
25602 
    oprot.writeStructBegin('getCostingForMarketplace_args')
25603 
    if self.source is not None:
25604 
      oprot.writeFieldBegin('source', TType.I64, 1)
25605 
      oprot.writeI64(self.source)
25606 
      oprot.writeFieldEnd()
25607 
    if self.item_id is not None:
25608 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
25609 
      oprot.writeI64(self.item_id)
25610 
      oprot.writeFieldEnd()
25611 
    oprot.writeFieldStop()
25612 
    oprot.writeStructEnd()
25613 
 
25614 
  def validate(self):
25615 
    return
25616 
 
25617 
 
25618 
  def __repr__(self):
25619 
    L = ['%s=%r' % (key, value)
25620 
      for key, value in self.__dict__.iteritems()]
25621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25622 
 
25623 
  def __eq__(self, other):
25624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25625 
 
25626 
  def __ne__(self, other):
25627 
    return not (self == other)
25628 
 
25629 
class getCostingForMarketplace_result:
25630 
  """
25631 
  Attributes:
25632 
   - success
25633 
  """
25634 
 
25635 
  thrift_spec = (
25636 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
25637 
  )
25638 
 
25639 
  def __init__(self, success=None,):
25640 
    self.success = success
25641 
 
25642 
  def read(self, iprot):
25643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25645 
      return
25646 
    iprot.readStructBegin()
25647 
    while True:
25648 
      (fname, ftype, fid) = iprot.readFieldBegin()
25649 
      if ftype == TType.STOP:
25650 
        break
25651 
      if fid == 0:
25652 
        if ftype == TType.STRUCT:
25653 
          self.success = MarketplacePercentage()
25654 
          self.success.read(iprot)
25655 
        else:
25656 
          iprot.skip(ftype)
25657 
      else:
25658 
        iprot.skip(ftype)
25659 
      iprot.readFieldEnd()
25660 
    iprot.readStructEnd()
25661 
 
25662 
  def write(self, oprot):
25663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25665 
      return
25666 
    oprot.writeStructBegin('getCostingForMarketplace_result')
25667 
    if self.success is not None:
25668 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25669 
      self.success.write(oprot)
25670 
      oprot.writeFieldEnd()
25671 
    oprot.writeFieldStop()
25672 
    oprot.writeStructEnd()
25673 
 
25674 
  def validate(self):
25675 
    return
25676 
 
25677 
 
25678 
  def __repr__(self):
25679 
    L = ['%s=%r' % (key, value)
25680 
      for key, value in self.__dict__.iteritems()]
25681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25682 
 
25683 
  def __eq__(self, other):
25684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25685 
 
25686 
  def __ne__(self, other):
25687 
    return not (self == other)
25688 
 
9776 vikram.rag 25689 
class getMarketPlaceItemsForPriceUpdate_args:
25690 
  """
25691 
  Attributes:
25692 
   - source
25693 
  """
25694 
 
25695 
  thrift_spec = (
25696 
    None, # 0
25697 
    (1, TType.I64, 'source', None, None, ), # 1
25698 
  )
25699 
 
25700 
  def __init__(self, source=None,):
25701 
    self.source = source
25702 
 
25703 
  def read(self, iprot):
25704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25706 
      return
25707 
    iprot.readStructBegin()
25708 
    while True:
25709 
      (fname, ftype, fid) = iprot.readFieldBegin()
25710 
      if ftype == TType.STOP:
25711 
        break
25712 
      if fid == 1:
25713 
        if ftype == TType.I64:
25714 
          self.source = iprot.readI64();
25715 
        else:
25716 
          iprot.skip(ftype)
25717 
      else:
25718 
        iprot.skip(ftype)
25719 
      iprot.readFieldEnd()
25720 
    iprot.readStructEnd()
25721 
 
25722 
  def write(self, oprot):
25723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25725 
      return
25726 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
25727 
    if self.source is not None:
25728 
      oprot.writeFieldBegin('source', TType.I64, 1)
25729 
      oprot.writeI64(self.source)
25730 
      oprot.writeFieldEnd()
25731 
    oprot.writeFieldStop()
25732 
    oprot.writeStructEnd()
25733 
 
25734 
  def validate(self):
25735 
    return
25736 
 
25737 
 
25738 
  def __repr__(self):
25739 
    L = ['%s=%r' % (key, value)
25740 
      for key, value in self.__dict__.iteritems()]
25741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25742 
 
25743 
  def __eq__(self, other):
25744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25745 
 
25746 
  def __ne__(self, other):
25747 
    return not (self == other)
25748 
 
25749 
class getMarketPlaceItemsForPriceUpdate_result:
25750 
  """
25751 
  Attributes:
25752 
   - success
25753 
  """
25754 
 
25755 
  thrift_spec = (
25756 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
25757 
  )
25758 
 
25759 
  def __init__(self, success=None,):
25760 
    self.success = success
25761 
 
25762 
  def read(self, iprot):
25763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25765 
      return
25766 
    iprot.readStructBegin()
25767 
    while True:
25768 
      (fname, ftype, fid) = iprot.readFieldBegin()
25769 
      if ftype == TType.STOP:
25770 
        break
25771 
      if fid == 0:
25772 
        if ftype == TType.LIST:
25773 
          self.success = []
25774 
          (_etype558, _size555) = iprot.readListBegin()
25775 
          for _i559 in xrange(_size555):
25776 
            _elem560 = MarketPlaceItemPrice()
25777 
            _elem560.read(iprot)
25778 
            self.success.append(_elem560)
25779 
          iprot.readListEnd()
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('getMarketPlaceItemsForPriceUpdate_result')
25792 
    if self.success is not None:
25793 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25794 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25795 
      for iter561 in self.success:
25796 
        iter561.write(oprot)
25797 
      oprot.writeListEnd()
25798 
      oprot.writeFieldEnd()
25799 
    oprot.writeFieldStop()
25800 
    oprot.writeStructEnd()
25801 
 
25802 
  def validate(self):
25803 
    return
25804 
 
25805 
 
25806 
  def __repr__(self):
25807 
    L = ['%s=%r' % (key, value)
25808 
      for key, value in self.__dict__.iteritems()]
25809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25810 
 
25811 
  def __eq__(self, other):
25812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25813 
 
25814 
  def __ne__(self, other):
25815 
    return not (self == other)
25816 
 
25817 
class updateMarketPlacePriceUpdateStatus_args:
25818 
  """
25819 
  Attributes:
25820 
   - skulist
25821 
   - timestamp
9816 kshitij.so 25822 
   - source
9776 vikram.rag 25823 
  """
25824 
 
25825 
  thrift_spec = (
25826 
    None, # 0
25827 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
25828 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 25829 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 25830 
  )
25831 
 
9816 kshitij.so 25832 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 25833 
    self.skulist = skulist
25834 
    self.timestamp = timestamp
9816 kshitij.so 25835 
    self.source = source
9776 vikram.rag 25836 
 
25837 
  def read(self, iprot):
25838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25840 
      return
25841 
    iprot.readStructBegin()
25842 
    while True:
25843 
      (fname, ftype, fid) = iprot.readFieldBegin()
25844 
      if ftype == TType.STOP:
25845 
        break
25846 
      if fid == 1:
25847 
        if ftype == TType.LIST:
25848 
          self.skulist = []
25849 
          (_etype565, _size562) = iprot.readListBegin()
25850 
          for _i566 in xrange(_size562):
25851 
            _elem567 = iprot.readI64();
25852 
            self.skulist.append(_elem567)
25853 
          iprot.readListEnd()
25854 
        else:
25855 
          iprot.skip(ftype)
25856 
      elif fid == 2:
25857 
        if ftype == TType.I64:
25858 
          self.timestamp = iprot.readI64();
25859 
        else:
25860 
          iprot.skip(ftype)
9816 kshitij.so 25861 
      elif fid == 3:
25862 
        if ftype == TType.I64:
25863 
          self.source = iprot.readI64();
25864 
        else:
25865 
          iprot.skip(ftype)
9776 vikram.rag 25866 
      else:
25867 
        iprot.skip(ftype)
25868 
      iprot.readFieldEnd()
25869 
    iprot.readStructEnd()
25870 
 
25871 
  def write(self, oprot):
25872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25874 
      return
25875 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
25876 
    if self.skulist is not None:
25877 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
25878 
      oprot.writeListBegin(TType.I64, len(self.skulist))
25879 
      for iter568 in self.skulist:
25880 
        oprot.writeI64(iter568)
25881 
      oprot.writeListEnd()
25882 
      oprot.writeFieldEnd()
25883 
    if self.timestamp is not None:
25884 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
25885 
      oprot.writeI64(self.timestamp)
25886 
      oprot.writeFieldEnd()
9816 kshitij.so 25887 
    if self.source is not None:
25888 
      oprot.writeFieldBegin('source', TType.I64, 3)
25889 
      oprot.writeI64(self.source)
25890 
      oprot.writeFieldEnd()
9776 vikram.rag 25891 
    oprot.writeFieldStop()
25892 
    oprot.writeStructEnd()
25893 
 
25894 
  def validate(self):
25895 
    return
25896 
 
25897 
 
25898 
  def __repr__(self):
25899 
    L = ['%s=%r' % (key, value)
25900 
      for key, value in self.__dict__.iteritems()]
25901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25902 
 
25903 
  def __eq__(self, other):
25904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25905 
 
25906 
  def __ne__(self, other):
25907 
    return not (self == other)
25908 
 
25909 
class updateMarketPlacePriceUpdateStatus_result:
25910 
 
25911 
  thrift_spec = (
25912 
  )
25913 
 
25914 
  def read(self, iprot):
25915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25917 
      return
25918 
    iprot.readStructBegin()
25919 
    while True:
25920 
      (fname, ftype, fid) = iprot.readFieldBegin()
25921 
      if ftype == TType.STOP:
25922 
        break
25923 
      else:
25924 
        iprot.skip(ftype)
25925 
      iprot.readFieldEnd()
25926 
    iprot.readStructEnd()
25927 
 
25928 
  def write(self, oprot):
25929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25931 
      return
25932 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
25933 
    oprot.writeFieldStop()
25934 
    oprot.writeStructEnd()
25935 
 
25936 
  def validate(self):
25937 
    return
25938 
 
25939 
 
25940 
  def __repr__(self):
25941 
    L = ['%s=%r' % (key, value)
25942 
      for key, value in self.__dict__.iteritems()]
25943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25944 
 
25945 
  def __eq__(self, other):
25946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25947 
 
25948 
  def __ne__(self, other):
25949 
    return not (self == other)
9861 rajveer 25950 
 
25951 
class updateItemHoldInventory_args:
25952 
  """
25953 
  Attributes:
25954 
   - itemHoldMap
25955 
  """
25956 
 
25957 
  thrift_spec = (
25958 
    None, # 0
25959 
    (1, TType.MAP, 'itemHoldMap', (TType.I64,None,TType.I64,None), None, ), # 1
25960 
  )
25961 
 
25962 
  def __init__(self, itemHoldMap=None,):
25963 
    self.itemHoldMap = itemHoldMap
25964 
 
25965 
  def read(self, iprot):
25966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25968 
      return
25969 
    iprot.readStructBegin()
25970 
    while True:
25971 
      (fname, ftype, fid) = iprot.readFieldBegin()
25972 
      if ftype == TType.STOP:
25973 
        break
25974 
      if fid == 1:
25975 
        if ftype == TType.MAP:
25976 
          self.itemHoldMap = {}
25977 
          (_ktype570, _vtype571, _size569 ) = iprot.readMapBegin()
25978 
          for _i573 in xrange(_size569):
25979 
            _key574 = iprot.readI64();
25980 
            _val575 = iprot.readI64();
25981 
            self.itemHoldMap[_key574] = _val575
25982 
          iprot.readMapEnd()
25983 
        else:
25984 
          iprot.skip(ftype)
25985 
      else:
25986 
        iprot.skip(ftype)
25987 
      iprot.readFieldEnd()
25988 
    iprot.readStructEnd()
25989 
 
25990 
  def write(self, oprot):
25991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25993 
      return
25994 
    oprot.writeStructBegin('updateItemHoldInventory_args')
25995 
    if self.itemHoldMap is not None:
25996 
      oprot.writeFieldBegin('itemHoldMap', TType.MAP, 1)
25997 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemHoldMap))
25998 
      for kiter576,viter577 in self.itemHoldMap.items():
25999 
        oprot.writeI64(kiter576)
26000 
        oprot.writeI64(viter577)
26001 
      oprot.writeMapEnd()
26002 
      oprot.writeFieldEnd()
26003 
    oprot.writeFieldStop()
26004 
    oprot.writeStructEnd()
26005 
 
26006 
  def validate(self):
26007 
    return
26008 
 
26009 
 
26010 
  def __repr__(self):
26011 
    L = ['%s=%r' % (key, value)
26012 
      for key, value in self.__dict__.iteritems()]
26013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26014 
 
26015 
  def __eq__(self, other):
26016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26017 
 
26018 
  def __ne__(self, other):
26019 
    return not (self == other)
26020 
 
26021 
class updateItemHoldInventory_result:
26022 
 
26023 
  thrift_spec = (
26024 
  )
26025 
 
26026 
  def read(self, iprot):
26027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26029 
      return
26030 
    iprot.readStructBegin()
26031 
    while True:
26032 
      (fname, ftype, fid) = iprot.readFieldBegin()
26033 
      if ftype == TType.STOP:
26034 
        break
26035 
      else:
26036 
        iprot.skip(ftype)
26037 
      iprot.readFieldEnd()
26038 
    iprot.readStructEnd()
26039 
 
26040 
  def write(self, oprot):
26041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26043 
      return
26044 
    oprot.writeStructBegin('updateItemHoldInventory_result')
26045 
    oprot.writeFieldStop()
26046 
    oprot.writeStructEnd()
26047 
 
26048 
  def validate(self):
26049 
    return
26050 
 
26051 
 
26052 
  def __repr__(self):
26053 
    L = ['%s=%r' % (key, value)
26054 
      for key, value in self.__dict__.iteritems()]
26055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26056 
 
26057 
  def __eq__(self, other):
26058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26059 
 
26060 
  def __ne__(self, other):
26061 
    return not (self == other)
9895 vikram.rag 26062 
 
26063 
class updateNlcAtMarketplaces_args:
26064 
  """
26065 
  Attributes:
26066 
   - item_id
26067 
   - vendor_id
26068 
   - nlc
26069 
  """
26070 
 
26071 
  thrift_spec = None
26072 
  def __init__(self, item_id=None, vendor_id=None, nlc=None,):
26073 
    self.item_id = item_id
26074 
    self.vendor_id = vendor_id
26075 
    self.nlc = nlc
26076 
 
26077 
  def read(self, iprot):
26078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26080 
      return
26081 
    iprot.readStructBegin()
26082 
    while True:
26083 
      (fname, ftype, fid) = iprot.readFieldBegin()
26084 
      if ftype == TType.STOP:
26085 
        break
26086 
      if fid == 1:
26087 
        if ftype == TType.I64:
26088 
          self.item_id = iprot.readI64();
26089 
        else:
26090 
          iprot.skip(ftype)
26091 
      elif fid == 2:
26092 
        if ftype == TType.I64:
26093 
          self.vendor_id = iprot.readI64();
26094 
        else:
26095 
          iprot.skip(ftype)
26096 
      elif fid == -1:
26097 
        if ftype == TType.DOUBLE:
26098 
          self.nlc = iprot.readDouble();
26099 
        else:
26100 
          iprot.skip(ftype)
26101 
      else:
26102 
        iprot.skip(ftype)
26103 
      iprot.readFieldEnd()
26104 
    iprot.readStructEnd()
26105 
 
26106 
  def write(self, oprot):
26107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26109 
      return
26110 
    oprot.writeStructBegin('updateNlcAtMarketplaces_args')
26111 
    if self.nlc is not None:
26112 
      oprot.writeFieldBegin('nlc', TType.DOUBLE, -1)
26113 
      oprot.writeDouble(self.nlc)
26114 
      oprot.writeFieldEnd()
26115 
    if self.item_id is not None:
26116 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26117 
      oprot.writeI64(self.item_id)
26118 
      oprot.writeFieldEnd()
26119 
    if self.vendor_id is not None:
26120 
      oprot.writeFieldBegin('vendor_id', TType.I64, 2)
26121 
      oprot.writeI64(self.vendor_id)
26122 
      oprot.writeFieldEnd()
26123 
    oprot.writeFieldStop()
26124 
    oprot.writeStructEnd()
26125 
 
26126 
  def validate(self):
26127 
    return
26128 
 
26129 
 
26130 
  def __repr__(self):
26131 
    L = ['%s=%r' % (key, value)
26132 
      for key, value in self.__dict__.iteritems()]
26133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26134 
 
26135 
  def __eq__(self, other):
26136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26137 
 
26138 
  def __ne__(self, other):
26139 
    return not (self == other)
26140 
 
26141 
class updateNlcAtMarketplaces_result:
26142 
 
26143 
  thrift_spec = (
26144 
  )
26145 
 
26146 
  def read(self, iprot):
26147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26149 
      return
26150 
    iprot.readStructBegin()
26151 
    while True:
26152 
      (fname, ftype, fid) = iprot.readFieldBegin()
26153 
      if ftype == TType.STOP:
26154 
        break
26155 
      else:
26156 
        iprot.skip(ftype)
26157 
      iprot.readFieldEnd()
26158 
    iprot.readStructEnd()
26159 
 
26160 
  def write(self, oprot):
26161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26163 
      return
26164 
    oprot.writeStructBegin('updateNlcAtMarketplaces_result')
26165 
    oprot.writeFieldStop()
26166 
    oprot.writeStructEnd()
26167 
 
26168 
  def validate(self):
26169 
    return
26170 
 
26171 
 
26172 
  def __repr__(self):
26173 
    L = ['%s=%r' % (key, value)
26174 
      for key, value in self.__dict__.iteritems()]
26175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26176 
 
26177 
  def __eq__(self, other):
26178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26179 
 
26180 
  def __ne__(self, other):
26181 
    return not (self == other)
9945 vikram.rag 26182 
 
26183 
class getAllFlipkartItems_args:
26184 
 
26185 
  thrift_spec = (
26186 
  )
26187 
 
26188 
  def read(self, iprot):
26189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26191 
      return
26192 
    iprot.readStructBegin()
26193 
    while True:
26194 
      (fname, ftype, fid) = iprot.readFieldBegin()
26195 
      if ftype == TType.STOP:
26196 
        break
26197 
      else:
26198 
        iprot.skip(ftype)
26199 
      iprot.readFieldEnd()
26200 
    iprot.readStructEnd()
26201 
 
26202 
  def write(self, oprot):
26203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26205 
      return
26206 
    oprot.writeStructBegin('getAllFlipkartItems_args')
26207 
    oprot.writeFieldStop()
26208 
    oprot.writeStructEnd()
26209 
 
26210 
  def validate(self):
26211 
    return
26212 
 
26213 
 
26214 
  def __repr__(self):
26215 
    L = ['%s=%r' % (key, value)
26216 
      for key, value in self.__dict__.iteritems()]
26217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26218 
 
26219 
  def __eq__(self, other):
26220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26221 
 
26222 
  def __ne__(self, other):
26223 
    return not (self == other)
26224 
 
26225 
class getAllFlipkartItems_result:
26226 
  """
26227 
  Attributes:
26228 
   - success
26229 
  """
26230 
 
26231 
  thrift_spec = (
26232 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
26233 
  )
26234 
 
26235 
  def __init__(self, success=None,):
26236 
    self.success = success
26237 
 
26238 
  def read(self, iprot):
26239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26241 
      return
26242 
    iprot.readStructBegin()
26243 
    while True:
26244 
      (fname, ftype, fid) = iprot.readFieldBegin()
26245 
      if ftype == TType.STOP:
26246 
        break
26247 
      if fid == 0:
26248 
        if ftype == TType.LIST:
26249 
          self.success = []
26250 
          (_etype581, _size578) = iprot.readListBegin()
26251 
          for _i582 in xrange(_size578):
26252 
            _elem583 = FlipkartItem()
26253 
            _elem583.read(iprot)
26254 
            self.success.append(_elem583)
26255 
          iprot.readListEnd()
26256 
        else:
26257 
          iprot.skip(ftype)
26258 
      else:
26259 
        iprot.skip(ftype)
26260 
      iprot.readFieldEnd()
26261 
    iprot.readStructEnd()
26262 
 
26263 
  def write(self, oprot):
26264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26266 
      return
26267 
    oprot.writeStructBegin('getAllFlipkartItems_result')
26268 
    if self.success is not None:
26269 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26270 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26271 
      for iter584 in self.success:
26272 
        iter584.write(oprot)
26273 
      oprot.writeListEnd()
26274 
      oprot.writeFieldEnd()
26275 
    oprot.writeFieldStop()
26276 
    oprot.writeStructEnd()
26277 
 
26278 
  def validate(self):
26279 
    return
26280 
 
26281 
 
26282 
  def __repr__(self):
26283 
    L = ['%s=%r' % (key, value)
26284 
      for key, value in self.__dict__.iteritems()]
26285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26286 
 
26287 
  def __eq__(self, other):
26288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26289 
 
26290 
  def __ne__(self, other):
26291 
    return not (self == other)
10097 kshitij.so 26292 
 
26293 
class addOrUpdateFlipkartItem_args:
26294 
  """
26295 
  Attributes:
26296 
   - flipkartitem
26297 
  """
26298 
 
26299 
  thrift_spec = None
26300 
  def __init__(self, flipkartitem=None,):
26301 
    self.flipkartitem = flipkartitem
26302 
 
26303 
  def read(self, iprot):
26304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26306 
      return
26307 
    iprot.readStructBegin()
26308 
    while True:
26309 
      (fname, ftype, fid) = iprot.readFieldBegin()
26310 
      if ftype == TType.STOP:
26311 
        break
26312 
      if fid == -1:
26313 
        if ftype == TType.STRUCT:
26314 
          self.flipkartitem = FlipkartItem()
26315 
          self.flipkartitem.read(iprot)
26316 
        else:
26317 
          iprot.skip(ftype)
26318 
      else:
26319 
        iprot.skip(ftype)
26320 
      iprot.readFieldEnd()
26321 
    iprot.readStructEnd()
26322 
 
26323 
  def write(self, oprot):
26324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26326 
      return
26327 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_args')
26328 
    if self.flipkartitem is not None:
26329 
      oprot.writeFieldBegin('flipkartitem', TType.STRUCT, -1)
26330 
      self.flipkartitem.write(oprot)
26331 
      oprot.writeFieldEnd()
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 addOrUpdateFlipkartItem_result:
26351 
  """
26352 
  Attributes:
26353 
   - success
26354 
  """
26355 
 
26356 
  thrift_spec = (
26357 
    (0, TType.BOOL, 'success', None, None, ), # 0
26358 
  )
26359 
 
26360 
  def __init__(self, success=None,):
26361 
    self.success = success
26362 
 
26363 
  def read(self, iprot):
26364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26366 
      return
26367 
    iprot.readStructBegin()
26368 
    while True:
26369 
      (fname, ftype, fid) = iprot.readFieldBegin()
26370 
      if ftype == TType.STOP:
26371 
        break
26372 
      if fid == 0:
26373 
        if ftype == TType.BOOL:
26374 
          self.success = iprot.readBool();
26375 
        else:
26376 
          iprot.skip(ftype)
26377 
      else:
26378 
        iprot.skip(ftype)
26379 
      iprot.readFieldEnd()
26380 
    iprot.readStructEnd()
26381 
 
26382 
  def write(self, oprot):
26383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26385 
      return
26386 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_result')
26387 
    if self.success is not None:
26388 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26389 
      oprot.writeBool(self.success)
26390 
      oprot.writeFieldEnd()
26391 
    oprot.writeFieldStop()
26392 
    oprot.writeStructEnd()
26393 
 
26394 
  def validate(self):
26395 
    return
26396 
 
26397 
 
26398 
  def __repr__(self):
26399 
    L = ['%s=%r' % (key, value)
26400 
      for key, value in self.__dict__.iteritems()]
26401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26402 
 
26403 
  def __eq__(self, other):
26404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26405 
 
26406 
  def __ne__(self, other):
26407 
    return not (self == other)
26408 
 
26409 
class getFlipkartItem_args:
26410 
  """
26411 
  Attributes:
26412 
   - item_id
26413 
  """
26414 
 
26415 
  thrift_spec = (
26416 
    None, # 0
26417 
    (1, TType.I64, 'item_id', None, None, ), # 1
26418 
  )
26419 
 
26420 
  def __init__(self, item_id=None,):
26421 
    self.item_id = item_id
26422 
 
26423 
  def read(self, iprot):
26424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26426 
      return
26427 
    iprot.readStructBegin()
26428 
    while True:
26429 
      (fname, ftype, fid) = iprot.readFieldBegin()
26430 
      if ftype == TType.STOP:
26431 
        break
26432 
      if fid == 1:
26433 
        if ftype == TType.I64:
26434 
          self.item_id = iprot.readI64();
26435 
        else:
26436 
          iprot.skip(ftype)
26437 
      else:
26438 
        iprot.skip(ftype)
26439 
      iprot.readFieldEnd()
26440 
    iprot.readStructEnd()
26441 
 
26442 
  def write(self, oprot):
26443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26445 
      return
26446 
    oprot.writeStructBegin('getFlipkartItem_args')
26447 
    if self.item_id is not None:
26448 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26449 
      oprot.writeI64(self.item_id)
26450 
      oprot.writeFieldEnd()
26451 
    oprot.writeFieldStop()
26452 
    oprot.writeStructEnd()
26453 
 
26454 
  def validate(self):
26455 
    return
26456 
 
26457 
 
26458 
  def __repr__(self):
26459 
    L = ['%s=%r' % (key, value)
26460 
      for key, value in self.__dict__.iteritems()]
26461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26462 
 
26463 
  def __eq__(self, other):
26464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26465 
 
26466 
  def __ne__(self, other):
26467 
    return not (self == other)
26468 
 
26469 
class getFlipkartItem_result:
26470 
  """
26471 
  Attributes:
26472 
   - success
26473 
  """
26474 
 
26475 
  thrift_spec = (
26476 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
26477 
  )
26478 
 
26479 
  def __init__(self, success=None,):
26480 
    self.success = success
26481 
 
26482 
  def read(self, iprot):
26483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26485 
      return
26486 
    iprot.readStructBegin()
26487 
    while True:
26488 
      (fname, ftype, fid) = iprot.readFieldBegin()
26489 
      if ftype == TType.STOP:
26490 
        break
26491 
      if fid == 0:
26492 
        if ftype == TType.STRUCT:
26493 
          self.success = FlipkartItem()
26494 
          self.success.read(iprot)
26495 
        else:
26496 
          iprot.skip(ftype)
26497 
      else:
26498 
        iprot.skip(ftype)
26499 
      iprot.readFieldEnd()
26500 
    iprot.readStructEnd()
26501 
 
26502 
  def write(self, oprot):
26503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26505 
      return
26506 
    oprot.writeStructBegin('getFlipkartItem_result')
26507 
    if self.success is not None:
26508 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26509 
      self.success.write(oprot)
26510 
      oprot.writeFieldEnd()
26511 
    oprot.writeFieldStop()
26512 
    oprot.writeStructEnd()
26513 
 
26514 
  def validate(self):
26515 
    return
26516 
 
26517 
 
26518 
  def __repr__(self):
26519 
    L = ['%s=%r' % (key, value)
26520 
      for key, value in self.__dict__.iteritems()]
26521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26522 
 
26523 
  def __eq__(self, other):
26524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26525 
 
26526 
  def __ne__(self, other):
26527 
    return not (self == other)
26528 
 
26529 
class getFlipkartItemDetails_args:
26530 
  """
26531 
  Attributes:
26532 
   - item_id
26533 
  """
26534 
 
26535 
  thrift_spec = (
26536 
    None, # 0
26537 
    (1, TType.I64, 'item_id', None, None, ), # 1
26538 
  )
26539 
 
26540 
  def __init__(self, item_id=None,):
26541 
    self.item_id = item_id
26542 
 
26543 
  def read(self, iprot):
26544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26546 
      return
26547 
    iprot.readStructBegin()
26548 
    while True:
26549 
      (fname, ftype, fid) = iprot.readFieldBegin()
26550 
      if ftype == TType.STOP:
26551 
        break
26552 
      if fid == 1:
26553 
        if ftype == TType.I64:
26554 
          self.item_id = iprot.readI64();
26555 
        else:
26556 
          iprot.skip(ftype)
26557 
      else:
26558 
        iprot.skip(ftype)
26559 
      iprot.readFieldEnd()
26560 
    iprot.readStructEnd()
26561 
 
26562 
  def write(self, oprot):
26563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26565 
      return
26566 
    oprot.writeStructBegin('getFlipkartItemDetails_args')
26567 
    if self.item_id is not None:
26568 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26569 
      oprot.writeI64(self.item_id)
26570 
      oprot.writeFieldEnd()
26571 
    oprot.writeFieldStop()
26572 
    oprot.writeStructEnd()
26573 
 
26574 
  def validate(self):
26575 
    return
26576 
 
26577 
 
26578 
  def __repr__(self):
26579 
    L = ['%s=%r' % (key, value)
26580 
      for key, value in self.__dict__.iteritems()]
26581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26582 
 
26583 
  def __eq__(self, other):
26584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26585 
 
26586 
  def __ne__(self, other):
26587 
    return not (self == other)
26588 
 
26589 
class getFlipkartItemDetails_result:
26590 
  """
26591 
  Attributes:
26592 
   - success
26593 
  """
26594 
 
26595 
  thrift_spec = (
26596 
    (0, TType.STRUCT, 'success', (FlipkartItemDetails, FlipkartItemDetails.thrift_spec), None, ), # 0
26597 
  )
26598 
 
26599 
  def __init__(self, success=None,):
26600 
    self.success = success
26601 
 
26602 
  def read(self, iprot):
26603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26605 
      return
26606 
    iprot.readStructBegin()
26607 
    while True:
26608 
      (fname, ftype, fid) = iprot.readFieldBegin()
26609 
      if ftype == TType.STOP:
26610 
        break
26611 
      if fid == 0:
26612 
        if ftype == TType.STRUCT:
26613 
          self.success = FlipkartItemDetails()
26614 
          self.success.read(iprot)
26615 
        else:
26616 
          iprot.skip(ftype)
26617 
      else:
26618 
        iprot.skip(ftype)
26619 
      iprot.readFieldEnd()
26620 
    iprot.readStructEnd()
26621 
 
26622 
  def write(self, oprot):
26623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26625 
      return
26626 
    oprot.writeStructBegin('getFlipkartItemDetails_result')
26627 
    if self.success is not None:
26628 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26629 
      self.success.write(oprot)
26630 
      oprot.writeFieldEnd()
26631 
    oprot.writeFieldStop()
26632 
    oprot.writeStructEnd()
26633 
 
26634 
  def validate(self):
26635 
    return
26636 
 
26637 
 
26638 
  def __repr__(self):
26639 
    L = ['%s=%r' % (key, value)
26640 
      for key, value in self.__dict__.iteritems()]
26641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26642 
 
26643 
  def __eq__(self, other):
26644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26645 
 
26646 
  def __ne__(self, other):
26647 
    return not (self == other)
26648 
 
26649 
class getFlipkartItems_args:
26650 
  """
26651 
  Attributes:
26652 
   - offset
26653 
   - limit
26654 
  """
26655 
 
26656 
  thrift_spec = (
26657 
    None, # 0
26658 
    (1, TType.I64, 'offset', None, None, ), # 1
26659 
    (2, TType.I64, 'limit', None, None, ), # 2
26660 
  )
26661 
 
26662 
  def __init__(self, offset=None, limit=None,):
26663 
    self.offset = offset
26664 
    self.limit = limit
26665 
 
26666 
  def read(self, iprot):
26667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26669 
      return
26670 
    iprot.readStructBegin()
26671 
    while True:
26672 
      (fname, ftype, fid) = iprot.readFieldBegin()
26673 
      if ftype == TType.STOP:
26674 
        break
26675 
      if fid == 1:
26676 
        if ftype == TType.I64:
26677 
          self.offset = iprot.readI64();
26678 
        else:
26679 
          iprot.skip(ftype)
26680 
      elif fid == 2:
26681 
        if ftype == TType.I64:
26682 
          self.limit = iprot.readI64();
26683 
        else:
26684 
          iprot.skip(ftype)
26685 
      else:
26686 
        iprot.skip(ftype)
26687 
      iprot.readFieldEnd()
26688 
    iprot.readStructEnd()
26689 
 
26690 
  def write(self, oprot):
26691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26693 
      return
26694 
    oprot.writeStructBegin('getFlipkartItems_args')
26695 
    if self.offset is not None:
26696 
      oprot.writeFieldBegin('offset', TType.I64, 1)
26697 
      oprot.writeI64(self.offset)
26698 
      oprot.writeFieldEnd()
26699 
    if self.limit is not None:
26700 
      oprot.writeFieldBegin('limit', TType.I64, 2)
26701 
      oprot.writeI64(self.limit)
26702 
      oprot.writeFieldEnd()
26703 
    oprot.writeFieldStop()
26704 
    oprot.writeStructEnd()
26705 
 
26706 
  def validate(self):
26707 
    return
26708 
 
26709 
 
26710 
  def __repr__(self):
26711 
    L = ['%s=%r' % (key, value)
26712 
      for key, value in self.__dict__.iteritems()]
26713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26714 
 
26715 
  def __eq__(self, other):
26716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26717 
 
26718 
  def __ne__(self, other):
26719 
    return not (self == other)
26720 
 
26721 
class getFlipkartItems_result:
26722 
  """
26723 
  Attributes:
26724 
   - success
26725 
  """
26726 
 
26727 
  thrift_spec = (
26728 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
26729 
  )
26730 
 
26731 
  def __init__(self, success=None,):
26732 
    self.success = success
26733 
 
26734 
  def read(self, iprot):
26735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26737 
      return
26738 
    iprot.readStructBegin()
26739 
    while True:
26740 
      (fname, ftype, fid) = iprot.readFieldBegin()
26741 
      if ftype == TType.STOP:
26742 
        break
26743 
      if fid == 0:
26744 
        if ftype == TType.LIST:
26745 
          self.success = []
26746 
          (_etype588, _size585) = iprot.readListBegin()
26747 
          for _i589 in xrange(_size585):
26748 
            _elem590 = FlipkartItemDetails()
26749 
            _elem590.read(iprot)
26750 
            self.success.append(_elem590)
26751 
          iprot.readListEnd()
26752 
        else:
26753 
          iprot.skip(ftype)
26754 
      else:
26755 
        iprot.skip(ftype)
26756 
      iprot.readFieldEnd()
26757 
    iprot.readStructEnd()
26758 
 
26759 
  def write(self, oprot):
26760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26762 
      return
26763 
    oprot.writeStructBegin('getFlipkartItems_result')
26764 
    if self.success is not None:
26765 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26766 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26767 
      for iter591 in self.success:
26768 
        iter591.write(oprot)
26769 
      oprot.writeListEnd()
26770 
      oprot.writeFieldEnd()
26771 
    oprot.writeFieldStop()
26772 
    oprot.writeStructEnd()
26773 
 
26774 
  def validate(self):
26775 
    return
26776 
 
26777 
 
26778 
  def __repr__(self):
26779 
    L = ['%s=%r' % (key, value)
26780 
      for key, value in self.__dict__.iteritems()]
26781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26782 
 
26783 
  def __eq__(self, other):
26784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26785 
 
26786 
  def __ne__(self, other):
26787 
    return not (self == other)
26788 
 
26789 
class searchFlipkartItems_args:
26790 
  """
26791 
  Attributes:
26792 
   - searchTerm
26793 
   - offset
26794 
   - limit
26795 
  """
26796 
 
26797 
  thrift_spec = (
26798 
    None, # 0
26799 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
26800 
    (2, TType.I64, 'offset', None, None, ), # 2
26801 
    (3, TType.I64, 'limit', None, None, ), # 3
26802 
  )
26803 
 
26804 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
26805 
    self.searchTerm = searchTerm
26806 
    self.offset = offset
26807 
    self.limit = limit
26808 
 
26809 
  def read(self, iprot):
26810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26812 
      return
26813 
    iprot.readStructBegin()
26814 
    while True:
26815 
      (fname, ftype, fid) = iprot.readFieldBegin()
26816 
      if ftype == TType.STOP:
26817 
        break
26818 
      if fid == 1:
26819 
        if ftype == TType.LIST:
26820 
          self.searchTerm = []
26821 
          (_etype595, _size592) = iprot.readListBegin()
26822 
          for _i596 in xrange(_size592):
26823 
            _elem597 = iprot.readString();
26824 
            self.searchTerm.append(_elem597)
26825 
          iprot.readListEnd()
26826 
        else:
26827 
          iprot.skip(ftype)
26828 
      elif fid == 2:
26829 
        if ftype == TType.I64:
26830 
          self.offset = iprot.readI64();
26831 
        else:
26832 
          iprot.skip(ftype)
26833 
      elif fid == 3:
26834 
        if ftype == TType.I64:
26835 
          self.limit = iprot.readI64();
26836 
        else:
26837 
          iprot.skip(ftype)
26838 
      else:
26839 
        iprot.skip(ftype)
26840 
      iprot.readFieldEnd()
26841 
    iprot.readStructEnd()
26842 
 
26843 
  def write(self, oprot):
26844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26846 
      return
26847 
    oprot.writeStructBegin('searchFlipkartItems_args')
26848 
    if self.searchTerm is not None:
26849 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
26850 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
26851 
      for iter598 in self.searchTerm:
26852 
        oprot.writeString(iter598)
26853 
      oprot.writeListEnd()
26854 
      oprot.writeFieldEnd()
26855 
    if self.offset is not None:
26856 
      oprot.writeFieldBegin('offset', TType.I64, 2)
26857 
      oprot.writeI64(self.offset)
26858 
      oprot.writeFieldEnd()
26859 
    if self.limit is not None:
26860 
      oprot.writeFieldBegin('limit', TType.I64, 3)
26861 
      oprot.writeI64(self.limit)
26862 
      oprot.writeFieldEnd()
26863 
    oprot.writeFieldStop()
26864 
    oprot.writeStructEnd()
26865 
 
26866 
  def validate(self):
26867 
    return
26868 
 
26869 
 
26870 
  def __repr__(self):
26871 
    L = ['%s=%r' % (key, value)
26872 
      for key, value in self.__dict__.iteritems()]
26873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26874 
 
26875 
  def __eq__(self, other):
26876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26877 
 
26878 
  def __ne__(self, other):
26879 
    return not (self == other)
26880 
 
26881 
class searchFlipkartItems_result:
26882 
  """
26883 
  Attributes:
26884 
   - success
26885 
  """
26886 
 
26887 
  thrift_spec = (
26888 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
26889 
  )
26890 
 
26891 
  def __init__(self, success=None,):
26892 
    self.success = success
26893 
 
26894 
  def read(self, iprot):
26895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26897 
      return
26898 
    iprot.readStructBegin()
26899 
    while True:
26900 
      (fname, ftype, fid) = iprot.readFieldBegin()
26901 
      if ftype == TType.STOP:
26902 
        break
26903 
      if fid == 0:
26904 
        if ftype == TType.LIST:
26905 
          self.success = []
26906 
          (_etype602, _size599) = iprot.readListBegin()
26907 
          for _i603 in xrange(_size599):
26908 
            _elem604 = FlipkartItemDetails()
26909 
            _elem604.read(iprot)
26910 
            self.success.append(_elem604)
26911 
          iprot.readListEnd()
26912 
        else:
26913 
          iprot.skip(ftype)
26914 
      else:
26915 
        iprot.skip(ftype)
26916 
      iprot.readFieldEnd()
26917 
    iprot.readStructEnd()
26918 
 
26919 
  def write(self, oprot):
26920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26922 
      return
26923 
    oprot.writeStructBegin('searchFlipkartItems_result')
26924 
    if self.success is not None:
26925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26926 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26927 
      for iter605 in self.success:
26928 
        iter605.write(oprot)
26929 
      oprot.writeListEnd()
26930 
      oprot.writeFieldEnd()
26931 
    oprot.writeFieldStop()
26932 
    oprot.writeStructEnd()
26933 
 
26934 
  def validate(self):
26935 
    return
26936 
 
26937 
 
26938 
  def __repr__(self):
26939 
    L = ['%s=%r' % (key, value)
26940 
      for key, value in self.__dict__.iteritems()]
26941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26942 
 
26943 
  def __eq__(self, other):
26944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26945 
 
26946 
  def __ne__(self, other):
26947 
    return not (self == other)
26948 
 
26949 
class getCountForFlipkartItems_args:
26950 
 
26951 
  thrift_spec = (
26952 
  )
26953 
 
26954 
  def read(self, iprot):
26955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26957 
      return
26958 
    iprot.readStructBegin()
26959 
    while True:
26960 
      (fname, ftype, fid) = iprot.readFieldBegin()
26961 
      if ftype == TType.STOP:
26962 
        break
26963 
      else:
26964 
        iprot.skip(ftype)
26965 
      iprot.readFieldEnd()
26966 
    iprot.readStructEnd()
26967 
 
26968 
  def write(self, oprot):
26969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26971 
      return
26972 
    oprot.writeStructBegin('getCountForFlipkartItems_args')
26973 
    oprot.writeFieldStop()
26974 
    oprot.writeStructEnd()
26975 
 
26976 
  def validate(self):
26977 
    return
26978 
 
26979 
 
26980 
  def __repr__(self):
26981 
    L = ['%s=%r' % (key, value)
26982 
      for key, value in self.__dict__.iteritems()]
26983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26984 
 
26985 
  def __eq__(self, other):
26986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26987 
 
26988 
  def __ne__(self, other):
26989 
    return not (self == other)
26990 
 
26991 
class getCountForFlipkartItems_result:
26992 
  """
26993 
  Attributes:
26994 
   - success
26995 
  """
26996 
 
26997 
  thrift_spec = (
26998 
    (0, TType.I64, 'success', None, None, ), # 0
26999 
  )
27000 
 
27001 
  def __init__(self, success=None,):
27002 
    self.success = success
27003 
 
27004 
  def read(self, iprot):
27005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27007 
      return
27008 
    iprot.readStructBegin()
27009 
    while True:
27010 
      (fname, ftype, fid) = iprot.readFieldBegin()
27011 
      if ftype == TType.STOP:
27012 
        break
27013 
      if fid == 0:
27014 
        if ftype == TType.I64:
27015 
          self.success = iprot.readI64();
27016 
        else:
27017 
          iprot.skip(ftype)
27018 
      else:
27019 
        iprot.skip(ftype)
27020 
      iprot.readFieldEnd()
27021 
    iprot.readStructEnd()
27022 
 
27023 
  def write(self, oprot):
27024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27026 
      return
27027 
    oprot.writeStructBegin('getCountForFlipkartItems_result')
27028 
    if self.success is not None:
27029 
      oprot.writeFieldBegin('success', TType.I64, 0)
27030 
      oprot.writeI64(self.success)
27031 
      oprot.writeFieldEnd()
27032 
    oprot.writeFieldStop()
27033 
    oprot.writeStructEnd()
27034 
 
27035 
  def validate(self):
27036 
    return
27037 
 
27038 
 
27039 
  def __repr__(self):
27040 
    L = ['%s=%r' % (key, value)
27041 
      for key, value in self.__dict__.iteritems()]
27042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27043 
 
27044 
  def __eq__(self, other):
27045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27046 
 
27047 
  def __ne__(self, other):
27048 
    return not (self == other)
27049 
 
27050 
class getFlipkartSearchResultCount_args:
27051 
  """
27052 
  Attributes:
27053 
   - searchTerm
27054 
  """
27055 
 
27056 
  thrift_spec = (
27057 
    None, # 0
27058 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
27059 
  )
27060 
 
27061 
  def __init__(self, searchTerm=None,):
27062 
    self.searchTerm = searchTerm
27063 
 
27064 
  def read(self, iprot):
27065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27067 
      return
27068 
    iprot.readStructBegin()
27069 
    while True:
27070 
      (fname, ftype, fid) = iprot.readFieldBegin()
27071 
      if ftype == TType.STOP:
27072 
        break
27073 
      if fid == 1:
27074 
        if ftype == TType.LIST:
27075 
          self.searchTerm = []
27076 
          (_etype609, _size606) = iprot.readListBegin()
27077 
          for _i610 in xrange(_size606):
27078 
            _elem611 = iprot.readString();
27079 
            self.searchTerm.append(_elem611)
27080 
          iprot.readListEnd()
27081 
        else:
27082 
          iprot.skip(ftype)
27083 
      else:
27084 
        iprot.skip(ftype)
27085 
      iprot.readFieldEnd()
27086 
    iprot.readStructEnd()
27087 
 
27088 
  def write(self, oprot):
27089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27091 
      return
27092 
    oprot.writeStructBegin('getFlipkartSearchResultCount_args')
27093 
    if self.searchTerm is not None:
27094 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
27095 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
27096 
      for iter612 in self.searchTerm:
27097 
        oprot.writeString(iter612)
27098 
      oprot.writeListEnd()
27099 
      oprot.writeFieldEnd()
27100 
    oprot.writeFieldStop()
27101 
    oprot.writeStructEnd()
27102 
 
27103 
  def validate(self):
27104 
    return
27105 
 
27106 
 
27107 
  def __repr__(self):
27108 
    L = ['%s=%r' % (key, value)
27109 
      for key, value in self.__dict__.iteritems()]
27110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27111 
 
27112 
  def __eq__(self, other):
27113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27114 
 
27115 
  def __ne__(self, other):
27116 
    return not (self == other)
27117 
 
27118 
class getFlipkartSearchResultCount_result:
27119 
  """
27120 
  Attributes:
27121 
   - success
27122 
  """
27123 
 
27124 
  thrift_spec = (
27125 
    (0, TType.I64, 'success', None, None, ), # 0
27126 
  )
27127 
 
27128 
  def __init__(self, success=None,):
27129 
    self.success = success
27130 
 
27131 
  def read(self, iprot):
27132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27134 
      return
27135 
    iprot.readStructBegin()
27136 
    while True:
27137 
      (fname, ftype, fid) = iprot.readFieldBegin()
27138 
      if ftype == TType.STOP:
27139 
        break
27140 
      if fid == 0:
27141 
        if ftype == TType.I64:
27142 
          self.success = iprot.readI64();
27143 
        else:
27144 
          iprot.skip(ftype)
27145 
      else:
27146 
        iprot.skip(ftype)
27147 
      iprot.readFieldEnd()
27148 
    iprot.readStructEnd()
27149 
 
27150 
  def write(self, oprot):
27151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27153 
      return
27154 
    oprot.writeStructBegin('getFlipkartSearchResultCount_result')
27155 
    if self.success is not None:
27156 
      oprot.writeFieldBegin('success', TType.I64, 0)
27157 
      oprot.writeI64(self.success)
27158 
      oprot.writeFieldEnd()
27159 
    oprot.writeFieldStop()
27160 
    oprot.writeStructEnd()
27161 
 
27162 
  def validate(self):
27163 
    return
27164 
 
27165 
 
27166 
  def __repr__(self):
27167 
    L = ['%s=%r' % (key, value)
27168 
      for key, value in self.__dict__.iteritems()]
27169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27170 
 
27171 
  def __eq__(self, other):
27172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27173 
 
27174 
  def __ne__(self, other):
27175 
    return not (self == other)
27176 
 
27177 
class getAllFkItems_args:
27178 
 
27179 
  thrift_spec = (
27180 
  )
27181 
 
27182 
  def read(self, iprot):
27183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27185 
      return
27186 
    iprot.readStructBegin()
27187 
    while True:
27188 
      (fname, ftype, fid) = iprot.readFieldBegin()
27189 
      if ftype == TType.STOP:
27190 
        break
27191 
      else:
27192 
        iprot.skip(ftype)
27193 
      iprot.readFieldEnd()
27194 
    iprot.readStructEnd()
27195 
 
27196 
  def write(self, oprot):
27197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27199 
      return
27200 
    oprot.writeStructBegin('getAllFkItems_args')
27201 
    oprot.writeFieldStop()
27202 
    oprot.writeStructEnd()
27203 
 
27204 
  def validate(self):
27205 
    return
27206 
 
27207 
 
27208 
  def __repr__(self):
27209 
    L = ['%s=%r' % (key, value)
27210 
      for key, value in self.__dict__.iteritems()]
27211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27212 
 
27213 
  def __eq__(self, other):
27214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27215 
 
27216 
  def __ne__(self, other):
27217 
    return not (self == other)
27218 
 
27219 
class getAllFkItems_result:
27220 
  """
27221 
  Attributes:
27222 
   - success
27223 
  """
27224 
 
27225 
  thrift_spec = (
27226 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27227 
  )
27228 
 
27229 
  def __init__(self, success=None,):
27230 
    self.success = success
27231 
 
27232 
  def read(self, iprot):
27233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27235 
      return
27236 
    iprot.readStructBegin()
27237 
    while True:
27238 
      (fname, ftype, fid) = iprot.readFieldBegin()
27239 
      if ftype == TType.STOP:
27240 
        break
27241 
      if fid == 0:
27242 
        if ftype == TType.LIST:
27243 
          self.success = []
27244 
          (_etype616, _size613) = iprot.readListBegin()
27245 
          for _i617 in xrange(_size613):
27246 
            _elem618 = FlipkartItemDetails()
27247 
            _elem618.read(iprot)
27248 
            self.success.append(_elem618)
27249 
          iprot.readListEnd()
27250 
        else:
27251 
          iprot.skip(ftype)
27252 
      else:
27253 
        iprot.skip(ftype)
27254 
      iprot.readFieldEnd()
27255 
    iprot.readStructEnd()
27256 
 
27257 
  def write(self, oprot):
27258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27260 
      return
27261 
    oprot.writeStructBegin('getAllFkItems_result')
27262 
    if self.success is not None:
27263 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27264 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27265 
      for iter619 in self.success:
27266 
        iter619.write(oprot)
27267 
      oprot.writeListEnd()
27268 
      oprot.writeFieldEnd()
27269 
    oprot.writeFieldStop()
27270 
    oprot.writeStructEnd()
27271 
 
27272 
  def validate(self):
27273 
    return
27274 
 
27275 
 
27276 
  def __repr__(self):
27277 
    L = ['%s=%r' % (key, value)
27278 
      for key, value in self.__dict__.iteritems()]
27279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27280 
 
27281 
  def __eq__(self, other):
27282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27283 
 
27284 
  def __ne__(self, other):
27285 
    return not (self == other)
10140 vikram.rag 27286 
 
27287 
class getFlipkartItemBySkyAtFlipkart_args:
27288 
  """
27289 
  Attributes:
27290 
   - sku
27291 
  """
27292 
 
27293 
  thrift_spec = None
27294 
  def __init__(self, sku=None,):
27295 
    self.sku = sku
27296 
 
27297 
  def read(self, iprot):
27298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27300 
      return
27301 
    iprot.readStructBegin()
27302 
    while True:
27303 
      (fname, ftype, fid) = iprot.readFieldBegin()
27304 
      if ftype == TType.STOP:
27305 
        break
27306 
      if fid == -1:
27307 
        if ftype == TType.STRING:
27308 
          self.sku = iprot.readString();
27309 
        else:
27310 
          iprot.skip(ftype)
27311 
      else:
27312 
        iprot.skip(ftype)
27313 
      iprot.readFieldEnd()
27314 
    iprot.readStructEnd()
27315 
 
27316 
  def write(self, oprot):
27317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27319 
      return
27320 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_args')
27321 
    if self.sku is not None:
27322 
      oprot.writeFieldBegin('sku', TType.STRING, -1)
27323 
      oprot.writeString(self.sku)
27324 
      oprot.writeFieldEnd()
27325 
    oprot.writeFieldStop()
27326 
    oprot.writeStructEnd()
27327 
 
27328 
  def validate(self):
27329 
    return
27330 
 
27331 
 
27332 
  def __repr__(self):
27333 
    L = ['%s=%r' % (key, value)
27334 
      for key, value in self.__dict__.iteritems()]
27335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27336 
 
27337 
  def __eq__(self, other):
27338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27339 
 
27340 
  def __ne__(self, other):
27341 
    return not (self == other)
27342 
 
27343 
class getFlipkartItemBySkyAtFlipkart_result:
27344 
  """
27345 
  Attributes:
27346 
   - success
27347 
  """
27348 
 
27349 
  thrift_spec = (
27350 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
27351 
  )
27352 
 
27353 
  def __init__(self, success=None,):
27354 
    self.success = success
27355 
 
27356 
  def read(self, iprot):
27357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27359 
      return
27360 
    iprot.readStructBegin()
27361 
    while True:
27362 
      (fname, ftype, fid) = iprot.readFieldBegin()
27363 
      if ftype == TType.STOP:
27364 
        break
27365 
      if fid == 0:
27366 
        if ftype == TType.STRUCT:
27367 
          self.success = FlipkartItem()
27368 
          self.success.read(iprot)
27369 
        else:
27370 
          iprot.skip(ftype)
27371 
      else:
27372 
        iprot.skip(ftype)
27373 
      iprot.readFieldEnd()
27374 
    iprot.readStructEnd()
27375 
 
27376 
  def write(self, oprot):
27377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27379 
      return
27380 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_result')
27381 
    if self.success is not None:
27382 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27383 
      self.success.write(oprot)
27384 
      oprot.writeFieldEnd()
27385 
    oprot.writeFieldStop()
27386 
    oprot.writeStructEnd()
27387 
 
27388 
  def validate(self):
27389 
    return
27390 
 
27391 
 
27392 
  def __repr__(self):
27393 
    L = ['%s=%r' % (key, value)
27394 
      for key, value in self.__dict__.iteritems()]
27395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27396 
 
27397 
  def __eq__(self, other):
27398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27399 
 
27400 
  def __ne__(self, other):
27401 
    return not (self == other)